HM\BackUpWordPress\Zip_File_Backup_Engine

Complexity

Total Complexity

19

Size/Duplication

Total Lines	159
Duplicated Lines	8.18 %

Coupling/Cohesion

Components	1
Dependencies	3

Importance

Changes	9
Bugs	0	Features	0

4 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	3	1
B	get_zip_executable_path()	0	29	3
B	backup()	7	40	6
C	get_exclude_string()	6	52	9

<?php

namespace HM\BackUpWordPress;

/**
 * Perform a file backup using the zip cli command
 */
class Zip_File_Backup_Engine extends File_Backup_Engine {

	/**
	 * The path to the zip executable
	 *
	 * @var string
	 */
	private $zip_executable_path = '';

	public function __construct() {
		parent::__construct();
	}

	/**
	 * Calculate the path to the zip executable.
	 *
	 * The executable path can be overridden using either the `HMBKP_ZIP_PATH`
	 * Constant or the `hmbkp_zip_executable_path` filter.
	 *
	 * If neither of those are set then we fallback to checking a number of
	 * common locations.
	 *
	 * @return string|false The path to the executable or false.
	 */
	public function get_zip_executable_path() {

		if ( defined( 'HMBKP_ZIP_PATH' ) ) {
			return HMBKP_ZIP_PATH;
		}

		/**
		 * Allow the executable path to be set via a filter
		 *
		 * @param string The path to the zip executable
		 */
		$this->zip_executable_path = apply_filters( 'hmbkp_zip_executable_path', '' );

		if ( ! $this->zip_executable_path ) {

			// List of possible zip locations
			$paths = array(
				'zip',
				'/usr/bin/zip',
				'/opt/local/bin/zip'
			);

			$this->zip_executable_path = Backup_Utilities::get_executable_path( $paths );

It seems like \HM\BackUpWordPress\Backup_Utilities::get_executable_path($paths) can also be of type false. However, the property $zip_executable_path is declared as type string. Maybe add an additional type check?

		}

		return $this->zip_executable_path;

	}

	/**
	 * Perform the file backup.
	 *
	 * @return bool Whether the backup completed successfully or not.
	 */
	public function backup() {

		if ( ! Backup_Utilities::is_exec_available() || ! $this->get_zip_executable_path() ) {

The expression $this->get_zip_executable_path() of type string|false is loosely compared to false; this is ambiguous if the string can be empty. You might want to explicitly use === false instead.

			return false;
		}

		// cd to the site root
		$command[] = 'cd ' . escapeshellarg( Path::get_root() );

$command was never initialized. Although not strictly required by PHP, it is generally a good practice to add $command = array(); before regardless.

		// Run the zip command with the recursive and quiet flags
		$command[] = '&& ' . escapeshellcmd( $this->get_zip_executable_path() ) . ' -rq';

		// Save the zip file to the correct path
		$command[] = escapeshellarg( $this->get_backup_filepath() ) . ' ./';

		// Pass exclude rules in if we have them
		if ( $this->get_exclude_string() ) {
			$command[] = '-x ' . $this->get_exclude_string();
		}

		// Push all output to STDERR
		$command[] = '2>&1';

		$command = implode( ' ', $command );
		$output = $return_status = 0;

		exec( $command, $output, $return_status );

		// Track any errors
		if ( $output ) {

This code seems to be duplicated across your project.

			if ( $return_status === 0 ) {
				$this->warning( __CLASS__, implode( ', ', $output ) );
			} else {
				$this->error( __CLASS__, implode( ', ', $output ) );
			}
		}

		return $this->verify_backup();

	}

	/**
	 * Convert the exclude rules to a format zip accepts
	 *
	 * @return string The exclude string ready to pass to `zip -x`
	 */
	public function get_exclude_string() {

		if ( ! $this->excludes ) {

The expression $this->excludes of type array is implicitly converted to a boolean; are you sure this is intended? If so, consider using empty($expr) instead to make it clear that you intend to check for an array without elements.

			return '';
		}

		$excludes = $this->excludes->get_excludes();

The method get_excludes cannot be called on $this->excludes (of type array).

		foreach ( $excludes as $key => &$rule ) {

			$file = $absolute = $fragment = false;

			// Files don't end with /
			if ( ! in_array( substr( $rule, - 1 ), array( '\\', '/' ) ) ) {
				$file = true;
			}

			// If rule starts with a / then treat as absolute path
			elseif ( in_array( substr( $rule, 0, 1 ), array( '\\', '/' ) ) ) {

This code seems to be duplicated across your project.

				$absolute = true;
			}

			// Otherwise treat as dir fragment
			else {
				$fragment = true;
			}

			$rule = str_ireplace( Path::get_root(), '', untrailingslashit( wp_normalize_path( $rule ) ) );

			// Strip the preceeding slash
			if ( in_array( substr( $rule, 0, 1 ), array( '\\', '/' ) ) ) {

This code seems to be duplicated across your project.

				$rule = substr( $rule, 1 );
			}

			// Wrap directory fragments and files in wildcards for zip
			if ( $fragment || $file ) {
				$rule = '*' . $rule . '*';
			}

			// Add a wildcard to the end of absolute url for zips
			if ( $absolute ) {
				$rule .= '*';
			}

		}

		// Escape shell args for zip command
		$excludes = array_map( 'escapeshellarg', array_unique( $excludes ) );

		return implode( ' -x ', $excludes );

	}

}