WordPress 4.6.1
[autoinstalls/wordpress.git] / wp-admin / includes / class-language-pack-upgrader.php
1 <?php
2 /**
3  * Upgrade API: Language_Pack_Upgrader class
4  *
5  * @package WordPress
6  * @subpackage Upgrader
7  * @since 4.6.0
8  */
9
10 /**
11  * Core class used for updating/installing language packs (translations)
12  * for plugins, themes, and core.
13  *
14  * @since 3.7.0
15  * @since 4.6.0 Moved to its own file from wp-admin/includes/class-wp-upgrader.php.
16  *
17  * @see WP_Upgrader
18  */
19 class Language_Pack_Upgrader extends WP_Upgrader {
20
21         /**
22          * Result of the language pack upgrade.
23          *
24          * @since 3.7.0
25          * @access public
26          * @var array|WP_Error $result
27          * @see WP_Upgrader::$result
28          */
29         public $result;
30
31         /**
32          * Whether a bulk upgrade/install is being performed.
33          *
34          * @since 3.7.0
35          * @access public
36          * @var bool $bulk
37          */
38         public $bulk = true;
39
40         /**
41          * Asynchronously upgrades language packs after other upgrades have been made.
42          *
43          * Hooked to the {@see 'upgrader_process_complete'} action by default.
44          *
45          * @since 3.7.0
46          * @access public
47          * @static
48          *
49          * @param false|WP_Upgrader $upgrader Optional. WP_Upgrader instance or false. If `$upgrader` is
50          *                                    a Language_Pack_Upgrader instance, the method will bail to
51          *                                    avoid recursion. Otherwise unused. Default false.
52          */
53         public static function async_upgrade( $upgrader = false ) {
54                 // Avoid recursion.
55                 if ( $upgrader && $upgrader instanceof Language_Pack_Upgrader ) {
56                         return;
57                 }
58
59                 // Nothing to do?
60                 $language_updates = wp_get_translation_updates();
61                 if ( ! $language_updates ) {
62                         return;
63                 }
64
65                 /*
66                  * Avoid messing with VCS installs, at least for now.
67                  * Noted: this is not the ideal way to accomplish this.
68                  */
69                 $check_vcs = new WP_Automatic_Updater;
70                 if ( $check_vcs->is_vcs_checkout( WP_CONTENT_DIR ) ) {
71                         return;
72                 }
73
74                 foreach ( $language_updates as $key => $language_update ) {
75                         $update = ! empty( $language_update->autoupdate );
76
77                         /**
78                          * Filters whether to asynchronously update translation for core, a plugin, or a theme.
79                          *
80                          * @since 4.0.0
81                          *
82                          * @param bool   $update          Whether to update.
83                          * @param object $language_update The update offer.
84                          */
85                         $update = apply_filters( 'async_update_translation', $update, $language_update );
86
87                         if ( ! $update ) {
88                                 unset( $language_updates[ $key ] );
89                         }
90                 }
91
92                 if ( empty( $language_updates ) ) {
93                         return;
94                 }
95
96                 // Re-use the automatic upgrader skin if the parent upgrader is using it.
97                 if ( $upgrader && $upgrader->skin instanceof Automatic_Upgrader_Skin ) {
98                         $skin = $upgrader->skin;
99                 } else {
100                         $skin = new Language_Pack_Upgrader_Skin( array(
101                                 'skip_header_footer' => true,
102                         ) );
103                 }
104
105                 $lp_upgrader = new Language_Pack_Upgrader( $skin );
106                 $lp_upgrader->bulk_upgrade( $language_updates );
107         }
108
109         /**
110          * Initialize the upgrade strings.
111          *
112          * @since 3.7.0
113          * @access public
114          */
115         public function upgrade_strings() {
116                 $this->strings['starting_upgrade'] = __( 'Some of your translations need updating. Sit tight for a few more seconds while we update them as well.' );
117                 $this->strings['up_to_date'] = __( 'The translations are up to date.' );
118                 $this->strings['no_package'] = __( 'Update package not available.' );
119                 $this->strings['downloading_package'] = __( 'Downloading translation from <span class="code">%s</span>&#8230;' );
120                 $this->strings['unpack_package'] = __( 'Unpacking the update&#8230;' );
121                 $this->strings['process_failed'] = __( 'Translation update failed.' );
122                 $this->strings['process_success'] = __( 'Translation updated successfully.' );
123         }
124
125         /**
126          * Upgrade a language pack.
127          *
128          * @since 3.7.0
129          * @access public
130          *
131          * @param string|false $update Optional. Whether an update offer is available. Default false.
132          * @param array        $args   Optional. Other optional arguments, see
133          *                             Language_Pack_Upgrader::bulk_upgrade(). Default empty array.
134          * @return array|bool|WP_Error The result of the upgrade, or a WP_Error object instead.
135          */
136         public function upgrade( $update = false, $args = array() ) {
137                 if ( $update ) {
138                         $update = array( $update );
139                 }
140
141                 $results = $this->bulk_upgrade( $update, $args );
142
143                 if ( ! is_array( $results ) ) {
144                         return $results;
145                 }
146
147                 return $results[0];
148         }
149
150         /**
151          * Bulk upgrade language packs.
152          *
153          * @since 3.7.0
154          * @access public
155          *
156          * @global WP_Filesystem_Base $wp_filesystem Subclass
157          *
158          * @param array $language_updates Optional. Language pack updates. Default empty array.
159          * @param array $args {
160          *     Optional. Other arguments for upgrading multiple language packs. Default empty array
161          *
162          *     @type bool $clear_update_cache Whether to clear the update cache when done.
163          *                                    Default true.
164          * }
165          * @return array|bool|WP_Error Will return an array of results, or true if there are no updates,
166          *                                   false or WP_Error for initial errors.
167          */
168         public function bulk_upgrade( $language_updates = array(), $args = array() ) {
169                 global $wp_filesystem;
170
171                 $defaults = array(
172                         'clear_update_cache' => true,
173                 );
174                 $parsed_args = wp_parse_args( $args, $defaults );
175
176                 $this->init();
177                 $this->upgrade_strings();
178
179                 if ( ! $language_updates )
180                         $language_updates = wp_get_translation_updates();
181
182                 if ( empty( $language_updates ) ) {
183                         $this->skin->header();
184                         $this->skin->set_result( true );
185                         $this->skin->feedback( 'up_to_date' );
186                         $this->skin->bulk_footer();
187                         $this->skin->footer();
188                         return true;
189                 }
190
191                 if ( 'upgrader_process_complete' == current_filter() )
192                         $this->skin->feedback( 'starting_upgrade' );
193
194                 // Remove any existing upgrade filters from the plugin/theme upgraders #WP29425 & #WP29230
195                 remove_all_filters( 'upgrader_pre_install' );
196                 remove_all_filters( 'upgrader_clear_destination' );
197                 remove_all_filters( 'upgrader_post_install' );
198                 remove_all_filters( 'upgrader_source_selection' );
199
200                 add_filter( 'upgrader_source_selection', array( $this, 'check_package' ), 10, 2 );
201
202                 $this->skin->header();
203
204                 // Connect to the Filesystem first.
205                 $res = $this->fs_connect( array( WP_CONTENT_DIR, WP_LANG_DIR ) );
206                 if ( ! $res ) {
207                         $this->skin->footer();
208                         return false;
209                 }
210
211                 $results = array();
212
213                 $this->update_count = count( $language_updates );
214                 $this->update_current = 0;
215
216                 /*
217                  * The filesystem's mkdir() is not recursive. Make sure WP_LANG_DIR exists,
218                  * as we then may need to create a /plugins or /themes directory inside of it.
219                  */
220                 $remote_destination = $wp_filesystem->find_folder( WP_LANG_DIR );
221                 if ( ! $wp_filesystem->exists( $remote_destination ) )
222                         if ( ! $wp_filesystem->mkdir( $remote_destination, FS_CHMOD_DIR ) )
223                                 return new WP_Error( 'mkdir_failed_lang_dir', $this->strings['mkdir_failed'], $remote_destination );
224
225                 $language_updates_results = array();
226
227                 foreach ( $language_updates as $language_update ) {
228
229                         $this->skin->language_update = $language_update;
230
231                         $destination = WP_LANG_DIR;
232                         if ( 'plugin' == $language_update->type )
233                                 $destination .= '/plugins';
234                         elseif ( 'theme' == $language_update->type )
235                                 $destination .= '/themes';
236
237                         $this->update_current++;
238
239                         $options = array(
240                                 'package' => $language_update->package,
241                                 'destination' => $destination,
242                                 'clear_destination' => false,
243                                 'abort_if_destination_exists' => false, // We expect the destination to exist.
244                                 'clear_working' => true,
245                                 'is_multi' => true,
246                                 'hook_extra' => array(
247                                         'language_update_type' => $language_update->type,
248                                         'language_update' => $language_update,
249                                 )
250                         );
251
252                         $result = $this->run( $options );
253
254                         $results[] = $this->result;
255
256                         // Prevent credentials auth screen from displaying multiple times.
257                         if ( false === $result ) {
258                                 break;
259                         }
260
261                         $language_updates_results[] = array(
262                                 'language' => $language_update->language,
263                                 'type'     => $language_update->type,
264                                 'slug'     => isset( $language_update->slug ) ? $language_update->slug : 'default',
265                                 'version'  => $language_update->version,
266                         );
267                 }
268
269                 // Remove upgrade hooks which are not required for translation updates.
270                 remove_action( 'upgrader_process_complete', array( 'Language_Pack_Upgrader', 'async_upgrade' ), 20 );
271                 remove_action( 'upgrader_process_complete', 'wp_version_check' );
272                 remove_action( 'upgrader_process_complete', 'wp_update_plugins' );
273                 remove_action( 'upgrader_process_complete', 'wp_update_themes' );
274
275                 /** This action is documented in wp-admin/includes/class-wp-upgrader.php */
276                 do_action( 'upgrader_process_complete', $this, array(
277                         'action'       => 'update',
278                         'type'         => 'translation',
279                         'bulk'         => true,
280                         'translations' => $language_updates_results
281                 ) );
282
283                 // Re-add upgrade hooks.
284                 add_action( 'upgrader_process_complete', array( 'Language_Pack_Upgrader', 'async_upgrade' ), 20 );
285                 add_action( 'upgrader_process_complete', 'wp_version_check', 10, 0 );
286                 add_action( 'upgrader_process_complete', 'wp_update_plugins', 10, 0 );
287                 add_action( 'upgrader_process_complete', 'wp_update_themes', 10, 0 );
288
289                 $this->skin->bulk_footer();
290
291                 $this->skin->footer();
292
293                 // Clean up our hooks, in case something else does an upgrade on this connection.
294                 remove_filter( 'upgrader_source_selection', array( $this, 'check_package' ) );
295
296                 if ( $parsed_args['clear_update_cache'] ) {
297                         wp_clean_update_cache();
298                 }
299
300                 return $results;
301         }
302
303         /**
304          * Check the package source to make sure there are .mo and .po files.
305          *
306          * Hooked to the {@see 'upgrader_source_selection'} filter by
307          * Language_Pack_Upgrader::bulk_upgrade().
308          *
309          * @since 3.7.0
310          * @access public
311          *
312          * @global WP_Filesystem_Base $wp_filesystem Subclass
313          *
314          * @param string|WP_Error $source
315          * @param string          $remote_source
316          */
317         public function check_package( $source, $remote_source ) {
318                 global $wp_filesystem;
319
320                 if ( is_wp_error( $source ) )
321                         return $source;
322
323                 // Check that the folder contains a valid language.
324                 $files = $wp_filesystem->dirlist( $remote_source );
325
326                 // Check to see if a .po and .mo exist in the folder.
327                 $po = $mo = false;
328                 foreach ( (array) $files as $file => $filedata ) {
329                         if ( '.po' == substr( $file, -3 ) )
330                                 $po = true;
331                         elseif ( '.mo' == substr( $file, -3 ) )
332                                 $mo = true;
333                 }
334
335                 if ( ! $mo || ! $po ) {
336                         return new WP_Error( 'incompatible_archive_pomo', $this->strings['incompatible_archive'],
337                                 /* translators: 1: .po 2: .mo */
338                                 sprintf( __( 'The language pack is missing either the %1$s or %2$s files.' ),
339                                         '<code>.po</code>',
340                                         '<code>.mo</code>'
341                                 )
342                         );
343                 }
344
345                 return $source;
346         }
347
348         /**
349          * Get the name of an item being updated.
350          *
351          * @since 3.7.0
352          * @access public
353          *
354          * @param object $update The data for an update.
355          * @return string The name of the item being updated.
356          */
357         public function get_name_for_update( $update ) {
358                 switch ( $update->type ) {
359                         case 'core':
360                                 return 'WordPress'; // Not translated
361
362                         case 'theme':
363                                 $theme = wp_get_theme( $update->slug );
364                                 if ( $theme->exists() )
365                                         return $theme->Get( 'Name' );
366                                 break;
367                         case 'plugin':
368                                 $plugin_data = get_plugins( '/' . $update->slug );
369                                 $plugin_data = reset( $plugin_data );
370                                 if ( $plugin_data )
371                                         return $plugin_data['Name'];
372                                 break;
373                 }
374                 return '';
375         }
376
377 }