Jetpack_Autoupdate - Code Metrics - Inspection of "Update WCS JITM copy to indicate that services are..." - Automattic/jetpack - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — update/woocommerce-services-ji... ( ba84f5 )

by Jeff

created 2017-02-10 18:10 UTC

Jetpack_Autoupdate C

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	318
Duplicated Lines	14.47 %

Coupling/Cohesion

Components	1
Dependencies	3

Importance

Changes

Metric	Value
dl	46
loc	318
rs	6.018
c	0
b	0
f	0
wmc	61
lcom	1
cbo	3

14 Methods

Rating	Name	Duplication	Size	Complexity
A	init()	0	7	2
A	__construct()	0	9	2
A	autoupdate_plugin()	8	10	2
C	autoupdate_translation()	14	45	7
A	autoupdate_theme()	8	9	2
A	autoupdate_core()	0	8	2
A	expect()	0	6	2
A	automatic_updates_complete()	0	17	4
A	get_log()	0	7	1
B	log_items()	0	17	5
B	bump_stats()	16	36	6
C	get_successful_updates()	0	25	7
F	get_possible_failures()	0	44	11
C	get_plugin_slug()	0	22	8

How to fix Duplicated Code Complexity

Duplicated Code

Duplicate code is one of the most pungent code smells. A rule that is often used is to re-structure code once it is duplicated in three or more places.

Common duplication problems, and corresponding solutions are:

If you have the same expression in different places: Extract expression to a method
If you have the same method in different sub-classes: Extract method, and pull up field to the parent class
If you have the same code in unrelated classes: Consider extracting the code to a new class, and injecting that class

Complex Class

Tip: Before tackling complexity, make sure that you eliminate any duplication first. This often can reduce the size of classes significantly.

Complex classes like Jetpack_Autoupdate often do a lot of different things. To break such a class down, we need to identify a cohesive component within that class. A common approach to find such a component is to look for fields/methods that share the same prefixes, or suffixes. You can also have a look at the cohesion graph to spot any un-connected, or weakly-connected components.

Once you have determined the fields that belong together, you can apply the Extract Class refactoring. If the component makes sense as a sub-class, Extract Subclass is also a candidate, and is often faster.

While breaking up the class, it is a good idea to analyze how other classes use Jetpack_Autoupdate, and based on these observations, apply Extract Interface, too.

<?php

/**
 * Handles items that have been selected for automatic updates.
 * Hooks into WP_Automatic_Updater
 */
class Jetpack_Autoupdate {

	private $results = array();

	private $expected = array();

	private $success = array(
		'plugin' => array(),
		'theme'  => array(),
	);

	private $failed = array(
		'plugin' => array(),
		'theme'  => array(),
	);

	private static $instance = null;

	static function init() {
		if ( is_null( self::$instance ) ) {
			self::$instance = new Jetpack_Autoupdate;
		}

		return self::$instance;
	}

	private function __construct() {
		if ( Jetpack::is_module_active( 'manage' ) ) {
			add_filter( 'auto_update_plugin', array( $this, 'autoupdate_plugin' ), 10, 2 );
			add_filter( 'auto_update_theme', array( $this, 'autoupdate_theme' ), 10, 2 );
			add_filter( 'auto_update_core', array( $this, 'autoupdate_core' ), 10, 2 );
			add_filter( 'auto_update_translation', array( $this, 'autoupdate_translation' ), 10, 2 );
			add_action( 'automatic_updates_complete', array( $this, 'automatic_updates_complete' ), 999, 1 );
		}
	}

	public function autoupdate_plugin( $update, $item ) {
		$autoupdate_plugin_list = Jetpack_Options::get_option( 'autoupdate_plugins', array() );
		if ( in_array( $item->plugin, $autoupdate_plugin_list ) ) {
			$this->expect( $item->plugin, 'plugin' );

			return true;
		}

		return $update;
	}

	public function autoupdate_translation( $update, $item ) {
		// Autoupdate all translations
		if ( Jetpack_Options::get_option( 'autoupdate_translations', false ) ) {
			return true;
		}
		
		// Themes
		$autoupdate_themes_translations = Jetpack_Options::get_option( 'autoupdate_themes_translations', array() );
		$autoupdate_theme_list          = Jetpack_Options::get_option( 'autoupdate_themes', array() );

		/*
		$item = {
		  "type":"theme",
		  "slug":"twentyfourteen",
		  "language":"en_CA",
		  "version":"1.8",
		  "updated":"2015-07-18 11:27:20",
		  "package":"https:\/\/downloads.wordpress.org\/translation\/theme\/twentyfourteen\/1.8\/en_CA.zip",
		  "autoupdate":true
		}
		*/
		if ( ( in_array( $item->slug, $autoupdate_themes_translations )
		       || in_array( $item->slug, $autoupdate_theme_list ) )
		     && 'theme' === $item->type
		) {
			$this->expect( $item->type + ':' + $item->slug, 'translation' );

			return true;
		}

		// Plugins
		$autoupdate_plugin_translations = Jetpack_Options::get_option( 'autoupdate_plugins_translations', array() );
		$autoupdate_plugin_list         = Jetpack_Options::get_option( 'autoupdate_plugins', array() );
		$plugin_files = array_unique( array_merge( $autoupdate_plugin_list, $autoupdate_plugin_translations ) );
		$plugin_slugs = array_map( array( __CLASS__, 'get_plugin_slug' ), $plugin_files );

		if ( in_array( $item->slug, $plugin_slugs )
		     && 'plugin' === $item->type
		) {
			$this->expect( $item->type + ':' + $item->slug, 'translation' );
			return true;
		}

		return $update;
	}

	public function autoupdate_theme( $update, $item ) {
		$autoupdate_theme_list = Jetpack_Options::get_option( 'autoupdate_themes', array() );
		if ( in_array( $item->theme, $autoupdate_theme_list ) ) {
			$this->expect( $item->theme, 'theme' );
			return true;
		}

		return $update;
	}

	public function autoupdate_core( $update, $item ) {

		$autoupdate_core = Jetpack_Options::get_option( 'autoupdate_core', false );
		if ( $autoupdate_core ) {
			return $autoupdate_core;
		}

		return $update;
	}

	/**
	 * Stores the an item identifier to the expected array.
	 *
	 * @param string $item Example: 'jetpack/jetpack.php' for type 'plugin' or 'twentyfifteen' for type 'theme'
	 * @param string $type 'plugin' or 'theme'
	 */
	private function expect( $item, $type ) {
		if ( ! isset( $this->expected[ $type ] ) ) {
			$this->expected[ $type ] = array();
		}
		$this->expected[ $type ][] = $item;
	}

	/**
	 * On completion of an automatic update, let's store the results.
	 *
	 * @param $results - Sent by WP_Automatic_Updater after it completes an autoupdate action. Results may be empty.
	 */
	public function automatic_updates_complete( $results ) {
		if ( empty( $this->expected ) ) {
			return;
		}
		$this->results = empty( $results ) ? self::get_possible_failures() : $results;

		add_action( 'shutdown', array( $this, 'bump_stats' ) );

		Jetpack::init();

		$items_to_log = array( 'plugin', 'theme', 'translation' );
		foreach ( $items_to_log as $items ) {
			$this->log_items( $items );
		}

		Jetpack::log( 'autoupdates', $this->get_log() );
	}

	public function get_log() {
		return array(
			'results' => $this->results,
			'failed'  => $this->failed,
			'success' => $this->success
		);
	}

	/**
	 * Iterates through expected items ( plugins or themes ) and compares them to actual results.
	 *
	 * @param $items 'plugin' or 'theme'
	 */
	private function log_items( $items ) {
		if ( ! isset( $this->expected[ $items ] ) ) {
			return;
		}

		$item_results = $this->get_successful_updates( $items );

		if ( is_array( $this->expected[ $items ] ) ) {
			foreach ( $this->expected[ $items ] as $item ) {
				if ( in_array( $item, $item_results ) ) {
					$this->success[ $items ][] = $item;
				} else {
					$this->failed[ $items ][] = $item;
				}
			}
		}
	}

	public function bump_stats() {
		$instance = Jetpack::init();
		$log      = array();
		// Bump numbers
		if ( ! empty( $this->success['plugin'] ) ) {
			$instance->stat( 'autoupdates/plugin-success', count( $this->success['plugin'] ) );
			$log['plugins_success'] = $this->success['plugin'];
		}

		if ( ! empty( $this->failed['plugin'] ) ) {
			$instance->stat( 'autoupdates/plugin-fail', count( $this->failed['plugin'] ) );
			$log['plugins_failed'] = $this->failed['plugin'];
		}

		if ( ! empty( $this->success['theme'] ) ) {
			$instance->stat( 'autoupdates/theme-success', count( $this->success['theme'] ) );
			$log['themes_success'] = $this->success['theme'];
		}

		if ( ! empty( $this->failed['theme'] ) ) {
			$instance->stat( 'autoupdates/theme-fail', count( $this->failed['theme'] ) );
			$log['themes_failed'] = $this->failed['theme'];
		}

		$instance->do_stats( 'server_side' );

		// Send a more detailed log to logstash
		if ( ! empty( $log ) ) {
			Jetpack::load_xml_rpc_client();
			$xml            = new Jetpack_IXR_Client( array(
				'user_id' => get_current_user_id()
			) );
			$log['blog_id'] = Jetpack_Options::get_option( 'id' );
			$xml->query( 'jetpack.debug_autoupdate', $log );
		}
	}

	/**
	 * Parses the autoupdate results generated by WP_Automatic_Updater and returns a simple array of successful items
	 *
	 * @param string $type 'plugin' or 'theme'
	 *
	 * @return array
	 */
	private function get_successful_updates( $type ) {
		$successful_updates = array();

		if ( ! isset( $this->results[ $type ] ) ) {
			return $successful_updates;
		}

		foreach ( $this->results[ $type ] as $result ) {
			if ( $result->result ) {
				switch ( $type ) {
					case 'theme':
						$successful_updates[] = $result->item->theme;
						break;
					case 'plugin':
						$successful_updates[] = $result->item->plugin;
						break;
					case 'translation':
						$successful_updates[] = $result->item->type + ':' + $result->item->slug;
						break;
				}
			}
		}

		return $successful_updates;
	}

	static function get_possible_failures() {
		$result = array();
		// Lets check some reasons why it might not be working as expected
		include_once( ABSPATH . '/wp-admin/includes/admin.php' );
		include_once( ABSPATH . '/wp-admin/includes/class-wp-upgrader.php' );
		$upgrader = new WP_Automatic_Updater;

		if ( $upgrader->is_disabled() ) {
			$result[] = 'autoupdates-disabled';
		}
		if ( ! is_main_site() ) {
			$result[] = 'is-not-main-site';
		}
		if ( ! is_main_network() ) {
			$result[] = 'is-not-main-network';
		}
		if ( $upgrader->is_vcs_checkout( ABSPATH ) ) {
			$result[] = 'site-on-vcs';
		}
		if ( $upgrader->is_vcs_checkout( WP_PLUGIN_DIR ) ) {
			$result[] = 'plugin-directory-on-vcs';
		}
		if ( $upgrader->is_vcs_checkout( WP_CONTENT_DIR ) ) {
			$result[] = 'content-directory-on-vcs';
		}
		$lock = get_option( 'auto_updater.lock' );
		if ( $lock > ( time() - HOUR_IN_SECONDS ) ) {
			$result[] = 'lock-is-set';
		}
		$skin = new Automatic_Upgrader_Skin;
		include_once( ABSPATH . 'wp-admin/includes/file.php' );
		include_once( ABSPATH . 'wp-admin/includes/template.php' );
		if ( ! $skin->request_filesystem_credentials( false, ABSPATH, false ) ) {
			$result[] = 'no-system-write-access';
		}
		if ( ! $skin->request_filesystem_credentials( false, WP_PLUGIN_DIR, false ) ) {
			$result[] = 'no-plugin-directory-write-access';
		}
		if ( ! $skin->request_filesystem_credentials( false, WP_CONTENT_DIR, false ) ) {
			$result[] = 'no-wp-content-directory-write-access';
		}

		return $result;
	}

	static function get_plugin_slug( $plugin_file ) {
		$update_plugins   = get_site_transient( 'update_plugins' );
$a = "a";
$ab = "ab";
$abc = "abc";
		if ( isset( $update_plugins->no_update ) ) {
			if ( isset( $update_plugins->no_update[ $plugin_file ] ) ) {
				$slug = $update_plugins->no_update[ $plugin_file ]->slug;
			}
		}
		if ( empty( $slug ) && isset( $update_plugins->response ) ) {
			if ( isset( $update_plugins->response[ $plugin_file ] ) ) {
				$slug = $update_plugins->response[ $plugin_file ]->slug;
			}
		}

		// Try to infer from the plugin file if not cached
		if ( empty( $slug) ) {
			$slug = dirname( $plugin_file );
			if ( '.' === $slug ) {
				$slug = preg_replace("/(.+)\.php$/", "$1", $plugin_file );
			}
		}
		return $slug;
	}

}

Jetpack_Autoupdate::init();


1		<?php
2
3		/**
4		* Handles items that have been selected for automatic updates.
5		* Hooks into WP_Automatic_Updater
6		*/
7		class Jetpack_Autoupdate {
8
9		private $results = array();
10
11		private $expected = array();
12
13		private $success = array(
14		'plugin' => array(),
15		'theme' => array(),
16		);
17
18		private $failed = array(
19		'plugin' => array(),
20		'theme' => array(),
21		);
22
23		private static $instance = null;
24
25		static function init() {
26		if ( is_null( self::$instance ) ) {
27		self::$instance = new Jetpack_Autoupdate;
28		}
29
30		return self::$instance;
31		}
32
33		private function __construct() {
34		if ( Jetpack::is_module_active( 'manage' ) ) {
35		add_filter( 'auto_update_plugin', array( $this, 'autoupdate_plugin' ), 10, 2 );
36		add_filter( 'auto_update_theme', array( $this, 'autoupdate_theme' ), 10, 2 );
37		add_filter( 'auto_update_core', array( $this, 'autoupdate_core' ), 10, 2 );
38		add_filter( 'auto_update_translation', array( $this, 'autoupdate_translation' ), 10, 2 );
39		add_action( 'automatic_updates_complete', array( $this, 'automatic_updates_complete' ), 999, 1 );
40		}
41		}
42
43	View Code Duplication	public function autoupdate_plugin( $update, $item ) {
44		$autoupdate_plugin_list = Jetpack_Options::get_option( 'autoupdate_plugins', array() );
45		if ( in_array( $item->plugin, $autoupdate_plugin_list ) ) {
46		$this->expect( $item->plugin, 'plugin' );
47
48		return true;
49		}
50
51		return $update;
52		}
53
54		public function autoupdate_translation( $update, $item ) {
55		// Autoupdate all translations
56		if ( Jetpack_Options::get_option( 'autoupdate_translations', false ) ) {
57		return true;
58		}
59
60		// Themes
61		$autoupdate_themes_translations = Jetpack_Options::get_option( 'autoupdate_themes_translations', array() );
62		$autoupdate_theme_list = Jetpack_Options::get_option( 'autoupdate_themes', array() );
63
64		/*
65		$item = {
66		"type":"theme",
67		"slug":"twentyfourteen",
68		"language":"en_CA",
69		"version":"1.8",
70		"updated":"2015-07-18 11:27:20",
71		"package":"https:\/\/downloads.wordpress.org\/translation\/theme\/twentyfourteen\/1.8\/en_CA.zip",
72		"autoupdate":true
73		}
74		*/
75	View Code Duplication	if ( ( in_array( $item->slug, $autoupdate_themes_translations )
76		\|\| in_array( $item->slug, $autoupdate_theme_list ) )
77		&& 'theme' === $item->type
78		) {
79		$this->expect( $item->type + ':' + $item->slug, 'translation' );
80
81		return true;
82		}
83
84		// Plugins
85		$autoupdate_plugin_translations = Jetpack_Options::get_option( 'autoupdate_plugins_translations', array() );
86		$autoupdate_plugin_list = Jetpack_Options::get_option( 'autoupdate_plugins', array() );
87		$plugin_files = array_unique( array_merge( $autoupdate_plugin_list, $autoupdate_plugin_translations ) );
88		$plugin_slugs = array_map( array( __CLASS__, 'get_plugin_slug' ), $plugin_files );
89
90	View Code Duplication	if ( in_array( $item->slug, $plugin_slugs )
91		&& 'plugin' === $item->type
92		) {
93		$this->expect( $item->type + ':' + $item->slug, 'translation' );
94		return true;
95		}
96
97		return $update;
98		}
99
100	View Code Duplication	public function autoupdate_theme( $update, $item ) {
101		$autoupdate_theme_list = Jetpack_Options::get_option( 'autoupdate_themes', array() );
102		if ( in_array( $item->theme, $autoupdate_theme_list ) ) {
103		$this->expect( $item->theme, 'theme' );
104		return true;
105		}
106
107		return $update;
108		}
109
110		public function autoupdate_core( $update, $item ) {
		0 ignored issues – show Unused Code introduced 2015-11-20 23:03 UTC by Report Bug Copy Issue Report The parameter `$item` is not used and could be removed. This check looks from parameters that have been defined for a function or method, but which are not used in the method body. Loading history...
111		$autoupdate_core = Jetpack_Options::get_option( 'autoupdate_core', false );
112		if ( $autoupdate_core ) {
113		return $autoupdate_core;
114		}
115
116		return $update;
117		}
118
119		/**
120		* Stores the an item identifier to the expected array.
121		*
122		* @param string $item Example: 'jetpack/jetpack.php' for type 'plugin' or 'twentyfifteen' for type 'theme'
123		* @param string $type 'plugin' or 'theme'
124		*/
125		private function expect( $item, $type ) {
126		if ( ! isset( $this->expected[ $type ] ) ) {
127		$this->expected[ $type ] = array();
128		}
129		$this->expected[ $type ][] = $item;
130		}
131
132		/**
133		* On completion of an automatic update, let's store the results.
134		*
135		* @param $results - Sent by WP_Automatic_Updater after it completes an autoupdate action. Results may be empty.
136		*/
137		public function automatic_updates_complete( $results ) {
138		if ( empty( $this->expected ) ) {
139		return;
140		}
141		$this->results = empty( $results ) ? self::get_possible_failures() : $results;
142
143		add_action( 'shutdown', array( $this, 'bump_stats' ) );
144
145		Jetpack::init();
146
147		$items_to_log = array( 'plugin', 'theme', 'translation' );
148		foreach ( $items_to_log as $items ) {
149		$this->log_items( $items );
150		}
151
152		Jetpack::log( 'autoupdates', $this->get_log() );
153		}
154
155		public function get_log() {
156		return array(
157		'results' => $this->results,
158		'failed' => $this->failed,
159		'success' => $this->success
160		);
161		}
162
163		/**
164		* Iterates through expected items ( plugins or themes ) and compares them to actual results.
165		*
166		* @param $items 'plugin' or 'theme'
167		*/
168		private function log_items( $items ) {
169		if ( ! isset( $this->expected[ $items ] ) ) {
170		return;
171		}
172
173		$item_results = $this->get_successful_updates( $items );
174
175		if ( is_array( $this->expected[ $items ] ) ) {
176		foreach ( $this->expected[ $items ] as $item ) {
177		if ( in_array( $item, $item_results ) ) {
178		$this->success[ $items ][] = $item;
179		} else {
180		$this->failed[ $items ][] = $item;
181		}
182		}
183		}
184		}
185
186		public function bump_stats() {
187		$instance = Jetpack::init();
188		$log = array();
189		// Bump numbers
190	View Code Duplication	if ( ! empty( $this->success['plugin'] ) ) {
191		$instance->stat( 'autoupdates/plugin-success', count( $this->success['plugin'] ) );
192		$log['plugins_success'] = $this->success['plugin'];
193		}
194
195	View Code Duplication	if ( ! empty( $this->failed['plugin'] ) ) {
196		$instance->stat( 'autoupdates/plugin-fail', count( $this->failed['plugin'] ) );
197		$log['plugins_failed'] = $this->failed['plugin'];
198		}
199
200	View Code Duplication	if ( ! empty( $this->success['theme'] ) ) {
201		$instance->stat( 'autoupdates/theme-success', count( $this->success['theme'] ) );
202		$log['themes_success'] = $this->success['theme'];
203		}
204
205	View Code Duplication	if ( ! empty( $this->failed['theme'] ) ) {
206		$instance->stat( 'autoupdates/theme-fail', count( $this->failed['theme'] ) );
207		$log['themes_failed'] = $this->failed['theme'];
208		}
209
210		$instance->do_stats( 'server_side' );
211
212		// Send a more detailed log to logstash
213		if ( ! empty( $log ) ) {
214		Jetpack::load_xml_rpc_client();
215		$xml = new Jetpack_IXR_Client( array(
216		'user_id' => get_current_user_id()
217		) );
218		$log['blog_id'] = Jetpack_Options::get_option( 'id' );
219		$xml->query( 'jetpack.debug_autoupdate', $log );
220		}
221		}
222
223		/**
224		* Parses the autoupdate results generated by WP_Automatic_Updater and returns a simple array of successful items
225		*
226		* @param string $type 'plugin' or 'theme'
227		*
228		* @return array
229		*/
230		private function get_successful_updates( $type ) {
231		$successful_updates = array();
232
233		if ( ! isset( $this->results[ $type ] ) ) {
234		return $successful_updates;
235		}
236
237		foreach ( $this->results[ $type ] as $result ) {
238		if ( $result->result ) {
239		switch ( $type ) {
240		case 'theme':
241		$successful_updates[] = $result->item->theme;
242		break;
243		case 'plugin':
244		$successful_updates[] = $result->item->plugin;
245		break;
246		case 'translation':
247		$successful_updates[] = $result->item->type + ':' + $result->item->slug;
248		break;
249		}
250		}
251		}
252
253		return $successful_updates;
254		}
255
256		static function get_possible_failures() {
257		$result = array();
258		// Lets check some reasons why it might not be working as expected
259		include_once( ABSPATH . '/wp-admin/includes/admin.php' );
260		include_once( ABSPATH . '/wp-admin/includes/class-wp-upgrader.php' );
261		$upgrader = new WP_Automatic_Updater;
262
263		if ( $upgrader->is_disabled() ) {
264		$result[] = 'autoupdates-disabled';
265		}
266		if ( ! is_main_site() ) {
267		$result[] = 'is-not-main-site';
268		}
269		if ( ! is_main_network() ) {
270		$result[] = 'is-not-main-network';
271		}
272		if ( $upgrader->is_vcs_checkout( ABSPATH ) ) {
273		$result[] = 'site-on-vcs';
274		}
275		if ( $upgrader->is_vcs_checkout( WP_PLUGIN_DIR ) ) {
276		$result[] = 'plugin-directory-on-vcs';
277		}
278		if ( $upgrader->is_vcs_checkout( WP_CONTENT_DIR ) ) {
279		$result[] = 'content-directory-on-vcs';
280		}
281		$lock = get_option( 'auto_updater.lock' );
282		if ( $lock > ( time() - HOUR_IN_SECONDS ) ) {
283		$result[] = 'lock-is-set';
284		}
285		$skin = new Automatic_Upgrader_Skin;
286		include_once( ABSPATH . 'wp-admin/includes/file.php' );
287		include_once( ABSPATH . 'wp-admin/includes/template.php' );
288		if ( ! $skin->request_filesystem_credentials( false, ABSPATH, false ) ) {
289		$result[] = 'no-system-write-access';
290		}
291		if ( ! $skin->request_filesystem_credentials( false, WP_PLUGIN_DIR, false ) ) {
292		$result[] = 'no-plugin-directory-write-access';
293		}
294		if ( ! $skin->request_filesystem_credentials( false, WP_CONTENT_DIR, false ) ) {
295		$result[] = 'no-wp-content-directory-write-access';
296		}
297
298		return $result;
299		}
300
301		static function get_plugin_slug( $plugin_file ) {
302		$update_plugins = get_site_transient( 'update_plugins' );
		0 ignored issues – show Coding Style introduced 2016-11-11 15:27 UTC by Report Bug Copy Issue Report Equals sign not aligned correctly; expected 1 space but found 3 spaces This check looks for improperly formatted assignments. Every assignment must have exactly one space before and one space after the equals operator. To illustrate: $a = "a"; $ab = "ab"; $abc = "abc"; will have no issues, while $a = "a"; $ab = "ab"; $abc = "abc"; will report issues in lines 1 and 2. Loading history...
303		if ( isset( $update_plugins->no_update ) ) {
304		if ( isset( $update_plugins->no_update[ $plugin_file ] ) ) {
305		$slug = $update_plugins->no_update[ $plugin_file ]->slug;
306		}
307		}
308		if ( empty( $slug ) && isset( $update_plugins->response ) ) {
309		if ( isset( $update_plugins->response[ $plugin_file ] ) ) {
310		$slug = $update_plugins->response[ $plugin_file ]->slug;
311		}
312		}
313
314		// Try to infer from the plugin file if not cached
315		if ( empty( $slug) ) {
316		$slug = dirname( $plugin_file );
317		if ( '.' === $slug ) {
318		$slug = preg_replace("/(.+)\.php$/", "$1", $plugin_file );
319		}
320		}
321		return $slug;
322		}
323
324		}
325
326		Jetpack_Autoupdate::init();
327

Automattic / jetpack