nextcloud / server

lib/private/Files/Config/LazyStorageMountInfo.php

Indentation +50 added lines, -50 removed lines

@@ -29,60 +29,60 @@
 use OCP\IUser;
 
 class LazyStorageMountInfo extends CachedMountInfo {
-	/** @var IMountPoint */
-	private $mount;
+    /** @var IMountPoint */
+    private $mount;
 
-	/**
-	 * CachedMountInfo constructor.
-	 *
-	 * @param IUser $user
-	 * @param IMountPoint $mount
-	 */
-	public function __construct(IUser $user, IMountPoint $mount) {
-		$this->user = $user;
-		$this->mount = $mount;
-	}
+    /**
+     * CachedMountInfo constructor.
+     *
+     * @param IUser $user
+     * @param IMountPoint $mount
+     */
+    public function __construct(IUser $user, IMountPoint $mount) {
+        $this->user = $user;
+        $this->mount = $mount;
+    }
 
-	/**
-	 * @return int the numeric storage id of the mount
-	 */
-	public function getStorageId() {
-		if (!$this->storageId) {
-			$this->storageId = $this->mount->getNumericStorageId();
-		}
-		return parent::getStorageId();
-	}
+    /**
+     * @return int the numeric storage id of the mount
+     */
+    public function getStorageId() {
+        if (!$this->storageId) {
+            $this->storageId = $this->mount->getNumericStorageId();
+        }
+        return parent::getStorageId();
+    }
 
-	/**
-	 * @return int the fileid of the root of the mount
-	 */
-	public function getRootId() {
-		if (!$this->rootId) {
-			$this->rootId = $this->mount->getStorageRootId();
-		}
-		return parent::getRootId();
-	}
+    /**
+     * @return int the fileid of the root of the mount
+     */
+    public function getRootId() {
+        if (!$this->rootId) {
+            $this->rootId = $this->mount->getStorageRootId();
+        }
+        return parent::getRootId();
+    }
 
-	/**
-	 * @return string the mount point of the mount for the user
-	 */
-	public function getMountPoint() {
-		if (!$this->mountPoint) {
-			$this->mountPoint = $this->mount->getMountPoint();
-		}
-		return parent::getMountPoint();
-	}
+    /**
+     * @return string the mount point of the mount for the user
+     */
+    public function getMountPoint() {
+        if (!$this->mountPoint) {
+            $this->mountPoint = $this->mount->getMountPoint();
+        }
+        return parent::getMountPoint();
+    }
 
-	public function getMountId() {
-		return $this->mount->getMountId();
-	}
+    public function getMountId() {
+        return $this->mount->getMountId();
+    }
 
-	/**
-	 * Get the internal path (within the storage) of the root of the mount
-	 *
-	 * @return string
-	 */
-	public function getRootInternalPath() {
-		return $this->mount->getInternalPath($this->mount->getMountPoint());
-	}
+    /**
+     * Get the internal path (within the storage) of the root of the mount
+     *
+     * @return string
+     */
+    public function getRootInternalPath() {
+        return $this->mount->getInternalPath($this->mount->getMountPoint());
+    }
 }

lib/private/Files/Config/UserMountCacheListener.php

Indentation +15 added lines, -15 removed lines

@@ -29,21 +29,21 @@
  * Listen to hooks and update the mount cache as needed
  */
 class UserMountCacheListener {
-	/**
-	 * @var IUserMountCache
-	 */
-	private $userMountCache;
+    /**
+     * @var IUserMountCache
+     */
+    private $userMountCache;
 
-	/**
-	 * UserMountCacheListener constructor.
-	 *
-	 * @param IUserMountCache $userMountCache
-	 */
-	public function __construct(IUserMountCache $userMountCache) {
-		$this->userMountCache = $userMountCache;
-	}
+    /**
+     * UserMountCacheListener constructor.
+     *
+     * @param IUserMountCache $userMountCache
+     */
+    public function __construct(IUserMountCache $userMountCache) {
+        $this->userMountCache = $userMountCache;
+    }
 
-	public function listen(Manager $manager) {
-		$manager->listen('\OC\User', 'postDelete', [$this->userMountCache, 'removeUserMounts']);
-	}
+    public function listen(Manager $manager) {
+        $manager->listen('\OC\User', 'postDelete', [$this->userMountCache, 'removeUserMounts']);
+    }
 }

lib/private/Files/Config/CachedMountInfo.php

Indentation +110 added lines, -110 removed lines

@@ -28,114 +28,114 @@
 use OCP\IUser;
 
 class CachedMountInfo implements ICachedMountInfo {
-	/**
-	 * @var IUser
-	 */
-	protected $user;
-
-	/**
-	 * @var int
-	 */
-	protected $storageId;
-
-	/**
-	 * @var int
-	 */
-	protected $rootId;
-
-	/**
-	 * @var string
-	 */
-	protected $mountPoint;
-
-	/**
-	 * @var int|null
-	 */
-	protected $mountId;
-
-	/**
-	 * @var string
-	 */
-	protected $rootInternalPath;
-
-	/**
-	 * CachedMountInfo constructor.
-	 *
-	 * @param IUser $user
-	 * @param int $storageId
-	 * @param int $rootId
-	 * @param string $mountPoint
-	 * @param int|null $mountId
-	 * @param string $rootInternalPath
-	 */
-	public function __construct(IUser $user, $storageId, $rootId, $mountPoint, $mountId = null, $rootInternalPath = '') {
-		$this->user = $user;
-		$this->storageId = $storageId;
-		$this->rootId = $rootId;
-		$this->mountPoint = $mountPoint;
-		$this->mountId = $mountId;
-		$this->rootInternalPath = $rootInternalPath;
-	}
-
-	/**
-	 * @return IUser
-	 */
-	public function getUser() {
-		return $this->user;
-	}
-
-	/**
-	 * @return int the numeric storage id of the mount
-	 */
-	public function getStorageId() {
-		return $this->storageId;
-	}
-
-	/**
-	 * @return int the fileid of the root of the mount
-	 */
-	public function getRootId() {
-		return $this->rootId;
-	}
-
-	/**
-	 * @return Node the root node of the mount
-	 */
-	public function getMountPointNode() {
-		// TODO injection etc
-		Filesystem::initMountPoints($this->getUser()->getUID());
-		$userNode = \OC::$server->getUserFolder($this->getUser()->getUID());
-		$nodes = $userNode->getParent()->getById($this->getRootId());
-		if (count($nodes) > 0) {
-			return $nodes[0];
-		} else {
-			return null;
-		}
-	}
-
-	/**
-	 * @return string the mount point of the mount for the user
-	 */
-	public function getMountPoint() {
-		return $this->mountPoint;
-	}
-
-	/**
-	 * Get the id of the configured mount
-	 *
-	 * @return int|null mount id or null if not applicable
-	 * @since 9.1.0
-	 */
-	public function getMountId() {
-		return $this->mountId;
-	}
-
-	/**
-	 * Get the internal path (within the storage) of the root of the mount
-	 *
-	 * @return string
-	 */
-	public function getRootInternalPath() {
-		return $this->rootInternalPath;
-	}
+    /**
+     * @var IUser
+     */
+    protected $user;
+
+    /**
+     * @var int
+     */
+    protected $storageId;
+
+    /**
+     * @var int
+     */
+    protected $rootId;
+
+    /**
+     * @var string
+     */
+    protected $mountPoint;
+
+    /**
+     * @var int|null
+     */
+    protected $mountId;
+
+    /**
+     * @var string
+     */
+    protected $rootInternalPath;
+
+    /**
+     * CachedMountInfo constructor.
+     *
+     * @param IUser $user
+     * @param int $storageId
+     * @param int $rootId
+     * @param string $mountPoint
+     * @param int|null $mountId
+     * @param string $rootInternalPath
+     */
+    public function __construct(IUser $user, $storageId, $rootId, $mountPoint, $mountId = null, $rootInternalPath = '') {
+        $this->user = $user;
+        $this->storageId = $storageId;
+        $this->rootId = $rootId;
+        $this->mountPoint = $mountPoint;
+        $this->mountId = $mountId;
+        $this->rootInternalPath = $rootInternalPath;
+    }
+
+    /**
+     * @return IUser
+     */
+    public function getUser() {
+        return $this->user;
+    }
+
+    /**
+     * @return int the numeric storage id of the mount
+     */
+    public function getStorageId() {
+        return $this->storageId;
+    }
+
+    /**
+     * @return int the fileid of the root of the mount
+     */
+    public function getRootId() {
+        return $this->rootId;
+    }
+
+    /**
+     * @return Node the root node of the mount
+     */
+    public function getMountPointNode() {
+        // TODO injection etc
+        Filesystem::initMountPoints($this->getUser()->getUID());
+        $userNode = \OC::$server->getUserFolder($this->getUser()->getUID());
+        $nodes = $userNode->getParent()->getById($this->getRootId());
+        if (count($nodes) > 0) {
+            return $nodes[0];
+        } else {
+            return null;
+        }
+    }
+
+    /**
+     * @return string the mount point of the mount for the user
+     */
+    public function getMountPoint() {
+        return $this->mountPoint;
+    }
+
+    /**
+     * Get the id of the configured mount
+     *
+     * @return int|null mount id or null if not applicable
+     * @since 9.1.0
+     */
+    public function getMountId() {
+        return $this->mountId;
+    }
+
+    /**
+     * Get the internal path (within the storage) of the root of the mount
+     *
+     * @return string
+     */
+    public function getRootInternalPath() {
+        return $this->rootInternalPath;
+    }
 }

lib/private/Files/ObjectStore/StorageObjectStore.php

Indentation +53 added lines, -53 removed lines

@@ -28,63 +28,63 @@
  * Object store that wraps a storage backend, mostly for testing purposes
  */
 class StorageObjectStore implements IObjectStore {
-	/** @var IStorage */
-	private $storage;
+    /** @var IStorage */
+    private $storage;
 
-	/**
-	 * @param IStorage $storage
-	 */
-	public function __construct(IStorage $storage) {
-		$this->storage = $storage;
-	}
+    /**
+     * @param IStorage $storage
+     */
+    public function __construct(IStorage $storage) {
+        $this->storage = $storage;
+    }
 
-	/**
-	 * @return string the container or bucket name where objects are stored
-	 * @since 7.0.0
-	 */
-	function getStorageId() {
-		$this->storage->getId();
-	}
+    /**
+     * @return string the container or bucket name where objects are stored
+     * @since 7.0.0
+     */
+    function getStorageId() {
+        $this->storage->getId();
+    }
 
-	/**
-	 * @param string $urn the unified resource name used to identify the object
-	 * @return resource stream with the read data
-	 * @throws \Exception when something goes wrong, message will be logged
-	 * @since 7.0.0
-	 */
-	function readObject($urn) {
-		$handle = $this->storage->fopen($urn, 'r');
-		if ($handle) {
-			return $handle;
-		} else {
-			throw new \Exception();
-		}
-	}
+    /**
+     * @param string $urn the unified resource name used to identify the object
+     * @return resource stream with the read data
+     * @throws \Exception when something goes wrong, message will be logged
+     * @since 7.0.0
+     */
+    function readObject($urn) {
+        $handle = $this->storage->fopen($urn, 'r');
+        if ($handle) {
+            return $handle;
+        } else {
+            throw new \Exception();
+        }
+    }
 
-	/**
-	 * @param string $urn the unified resource name used to identify the object
-	 * @param resource $stream stream with the data to write
-	 * @throws \Exception when something goes wrong, message will be logged
-	 * @since 7.0.0
-	 */
-	function writeObject($urn, $stream) {
-		$handle = $this->storage->fopen($urn, 'w');
-		if ($handle) {
-			stream_copy_to_stream($stream, $handle);
-			fclose($handle);
-		} else {
-			throw new \Exception();
-		}
-	}
+    /**
+     * @param string $urn the unified resource name used to identify the object
+     * @param resource $stream stream with the data to write
+     * @throws \Exception when something goes wrong, message will be logged
+     * @since 7.0.0
+     */
+    function writeObject($urn, $stream) {
+        $handle = $this->storage->fopen($urn, 'w');
+        if ($handle) {
+            stream_copy_to_stream($stream, $handle);
+            fclose($handle);
+        } else {
+            throw new \Exception();
+        }
+    }
 
-	/**
-	 * @param string $urn the unified resource name used to identify the object
-	 * @return void
-	 * @throws \Exception when something goes wrong, message will be logged
-	 * @since 7.0.0
-	 */
-	function deleteObject($urn) {
-		$this->storage->unlink($urn);
-	}
+    /**
+     * @param string $urn the unified resource name used to identify the object
+     * @return void
+     * @throws \Exception when something goes wrong, message will be logged
+     * @since 7.0.0
+     */
+    function deleteObject($urn) {
+        $this->storage->unlink($urn);
+    }
 
 }

lib/private/Files/ObjectStore/HomeObjectStoreStorage.php

Indentation +33 added lines, -33 removed lines

@@ -28,42 +28,42 @@
 
 class HomeObjectStoreStorage extends ObjectStoreStorage implements \OCP\Files\IHomeStorage {
 
-	/**
-	 * The home user storage requires a user object to create a unique storage id
-	 * @param array $params
-	 */
-	public function __construct($params) {
-		if ( ! isset($params['user']) || ! $params['user'] instanceof User) {
-			throw new \Exception('missing user object in parameters');
-		}
-		$this->user = $params['user'];
-		parent::__construct($params);
-	}
+    /**
+     * The home user storage requires a user object to create a unique storage id
+     * @param array $params
+     */
+    public function __construct($params) {
+        if ( ! isset($params['user']) || ! $params['user'] instanceof User) {
+            throw new \Exception('missing user object in parameters');
+        }
+        $this->user = $params['user'];
+        parent::__construct($params);
+    }
 
-	public function getId () {
-		return 'object::user:' . $this->user->getUID();
-	}
+    public function getId () {
+        return 'object::user:' . $this->user->getUID();
+    }
 
-	/**
-	 * get the owner of a path
-	 *
-	 * @param string $path The path to get the owner
-	 * @return false|string uid
-	 */
-	public function getOwner($path) {
-		if (is_object($this->user)) {
-			return $this->user->getUID();
-		}
-		return false;
-	}
+    /**
+     * get the owner of a path
+     *
+     * @param string $path The path to get the owner
+     * @return false|string uid
+     */
+    public function getOwner($path) {
+        if (is_object($this->user)) {
+            return $this->user->getUID();
+        }
+        return false;
+    }
 
-	/**
-	 * @param string $path, optional
-	 * @return \OC\User\User
-	 */
-	public function getUser($path = null) {
-		return $this->user;
-	}
+    /**
+     * @param string $path, optional
+     * @return \OC\User\User
+     */
+    public function getUser($path = null) {
+        return $this->user;
+    }
 
 
 }
\ No newline at end of file

Spacing +3 added lines, -3 removed lines

@@ -33,15 +33,15 @@
 	 * @param array $params
 	 */
 	public function __construct($params) {
-		if ( ! isset($params['user']) || ! $params['user'] instanceof User) {
+		if (!isset($params['user']) || !$params['user'] instanceof User) {
 			throw new \Exception('missing user object in parameters');
 		}
 		$this->user = $params['user'];
 		parent::__construct($params);
 	}
 
-	public function getId () {
-		return 'object::user:' . $this->user->getUID();
+	public function getId() {
+		return 'object::user:'.$this->user->getUID();
 	}
 
 	/**

lib/private/Files/ObjectStore/NoopScanner.php

Indentation +44 added lines, -44 removed lines

@@ -29,52 +29,52 @@
 
 class NoopScanner extends Scanner {
 
-	public function __construct(Storage $storage) {
-		//we don't need the storage, so do nothing here
-	}
+    public function __construct(Storage $storage) {
+        //we don't need the storage, so do nothing here
+    }
 
-	/**
-	 * scan a single file and store it in the cache
-	 *
-	 * @param string $file
-	 * @param int $reuseExisting
-	 * @param int $parentId
-	 * @param array|null $cacheData existing data in the cache for the file to be scanned
-	 * @return array an array of metadata of the scanned file
-	 */
-	public function scanFile($file, $reuseExisting = 0, $parentId = -1, $cacheData = null, $lock = true) {
-		return array();
-	}
+    /**
+     * scan a single file and store it in the cache
+     *
+     * @param string $file
+     * @param int $reuseExisting
+     * @param int $parentId
+     * @param array|null $cacheData existing data in the cache for the file to be scanned
+     * @return array an array of metadata of the scanned file
+     */
+    public function scanFile($file, $reuseExisting = 0, $parentId = -1, $cacheData = null, $lock = true) {
+        return array();
+    }
 
-	/**
-	 * scan a folder and all it's children
-	 *
-	 * @param string $path
-	 * @param bool $recursive
-	 * @param int $reuse
-	 * @return array with the meta data of the scanned file or folder
-	 */
-	public function scan($path, $recursive = self::SCAN_RECURSIVE, $reuse = -1, $lock = true) {
-		return array();
-	}
+    /**
+     * scan a folder and all it's children
+     *
+     * @param string $path
+     * @param bool $recursive
+     * @param int $reuse
+     * @return array with the meta data of the scanned file or folder
+     */
+    public function scan($path, $recursive = self::SCAN_RECURSIVE, $reuse = -1, $lock = true) {
+        return array();
+    }
 
-	/**
-	 * scan all the files and folders in a folder
-	 *
-	 * @param string $path
-	 * @param bool $recursive
-	 * @param int $reuse
-	 * @param array $folderData existing cache data for the folder to be scanned
-	 * @return int the size of the scanned folder or -1 if the size is unknown at this stage
-	 */
-	protected function scanChildren($path, $recursive = self::SCAN_RECURSIVE, $reuse = -1, $folderData = null, $lock = true) {
-		return 0;
-	}
+    /**
+     * scan all the files and folders in a folder
+     *
+     * @param string $path
+     * @param bool $recursive
+     * @param int $reuse
+     * @param array $folderData existing cache data for the folder to be scanned
+     * @return int the size of the scanned folder or -1 if the size is unknown at this stage
+     */
+    protected function scanChildren($path, $recursive = self::SCAN_RECURSIVE, $reuse = -1, $folderData = null, $lock = true) {
+        return 0;
+    }
 
-	/**
-	 * walk over any folders that are not fully scanned yet and scan them
-	 */
-	public function backgroundScan() {
-		//noop
-	}
+    /**
+     * walk over any folders that are not fully scanned yet and scan them
+     */
+    public function backgroundScan() {
+        //noop
+    }
 }

lib/private/Files/ObjectStore/Mapper.php

Indentation +19 added lines, -19 removed lines

@@ -31,25 +31,25 @@
  * Map a user to a bucket.
  */
 class Mapper {
-	/** @var IUser */
-	private $user;
+    /** @var IUser */
+    private $user;
 
-	/**
-	 * Mapper constructor.
-	 *
-	 * @param IUser $user
-	 */
-	public function __construct(IUser $user) {
-		$this->user = $user;
-	}
+    /**
+     * Mapper constructor.
+     *
+     * @param IUser $user
+     */
+    public function __construct(IUser $user) {
+        $this->user = $user;
+    }
 
-	/**
-	 * @param int $numBuckets
-	 * @return string
-	 */
-	public function getBucket($numBuckets = 64) {
-		$hash = md5($this->user->getUID());
-		$num = hexdec(substr($hash, 0, 4));
-		return (string)($num % $numBuckets);
-	}
+    /**
+     * @param int $numBuckets
+     * @return string
+     */
+    public function getBucket($numBuckets = 64) {
+        $hash = md5($this->user->getUID());
+        $num = hexdec(substr($hash, 0, 4));
+        return (string)($num % $numBuckets);
+    }
 }

Spacing +1 added lines, -1 removed lines

@@ -50,6 +50,6 @@
 	public function getBucket($numBuckets = 64) {
 		$hash = md5($this->user->getUID());
 		$num = hexdec(substr($hash, 0, 4));
-		return (string)($num % $numBuckets);
+		return (string) ($num % $numBuckets);
 	}
 }

lib/private/Files/Type/Detection.php

Spacing +9 added lines, -9 removed lines

@@ -102,7 +102,7 @@ 
 
 		// Update the alternative mimetypes to avoid having to look them up each time.
 		foreach ($this->mimetypes as $mimeType) {
-			$this->secureMimeTypes[$mimeType[0]] = isset($mimeType[1]) ? $mimeType[1]: $mimeType[0];
+			$this->secureMimeTypes[$mimeType[0]] = isset($mimeType[1]) ? $mimeType[1] : $mimeType[0];
 		}
 	}
 
@@ -114,10 +114,10 @@ 
 			return;
 		}
 
-		$this->mimeTypeAlias = json_decode(file_get_contents($this->defaultConfigDir . '/mimetypealiases.dist.json'), true);
+		$this->mimeTypeAlias = json_decode(file_get_contents($this->defaultConfigDir.'/mimetypealiases.dist.json'), true);
 
-		if (file_exists($this->customConfigDir . '/mimetypealiases.json')) {
-			$custom = json_decode(file_get_contents($this->customConfigDir . '/mimetypealiases.json'), true);
+		if (file_exists($this->customConfigDir.'/mimetypealiases.json')) {
+			$custom = json_decode(file_get_contents($this->customConfigDir.'/mimetypealiases.json'), true);
 			$this->mimeTypeAlias = array_merge($this->mimeTypeAlias, $custom);
 		}
 	}
@@ -138,11 +138,11 @@ 
 			return;
 		}
 
-		$mimetypeMapping = json_decode(file_get_contents($this->defaultConfigDir . '/mimetypemapping.dist.json'), true);
+		$mimetypeMapping = json_decode(file_get_contents($this->defaultConfigDir.'/mimetypemapping.dist.json'), true);
 
 		//Check if need to load custom mappings
-		if (file_exists($this->customConfigDir . '/mimetypemapping.json')) {
-			$custom = json_decode(file_get_contents($this->customConfigDir . '/mimetypemapping.json'), true);
+		if (file_exists($this->customConfigDir.'/mimetypemapping.json')) {
+			$custom = json_decode(file_get_contents($this->customConfigDir.'/mimetypemapping.json'), true);
 			$mimetypeMapping = array_merge($mimetypeMapping, $custom);
 		}
 
@@ -306,7 +306,7 @@ 
 
 		// Icon exists?
 		try {
-			$this->mimetypeIcons[$mimetype] = $this->urlGenerator->imagePath('core', 'filetypes/' . $icon . '.svg');
+			$this->mimetypeIcons[$mimetype] = $this->urlGenerator->imagePath('core', 'filetypes/'.$icon.'.svg');
 			return $this->mimetypeIcons[$mimetype];
 		} catch (\RuntimeException $e) {
 			// Specified image not found
@@ -315,7 +315,7 @@ 
 		// Try only the first part of the filetype
 		$mimePart = substr($icon, 0, strpos($icon, '-'));
 		try {
-			$this->mimetypeIcons[$mimetype] = $this->urlGenerator->imagePath('core', 'filetypes/' . $mimePart . '.svg');
+			$this->mimetypeIcons[$mimetype] = $this->urlGenerator->imagePath('core', 'filetypes/'.$mimePart.'.svg');
 			return $this->mimetypeIcons[$mimetype];
 		} catch (\RuntimeException $e) {
 			// Image for the first part of the mimetype not found

Indentation +287 added lines, -287 removed lines

@@ -41,291 +41,291 @@
  * @package OC\Files\Type
  */
 class Detection implements IMimeTypeDetector {
-	protected $mimetypes = [];
-	protected $secureMimeTypes = [];
-
-	protected $mimetypeIcons = [];
-	/** @var string[] */
-	protected $mimeTypeAlias = [];
-
-	/** @var IURLGenerator */
-	private $urlGenerator;
-
-	/** @var string */
-	private $customConfigDir;
-
-	/** @var string */
-	private $defaultConfigDir;
-
-	/**
-	 * @param IURLGenerator $urlGenerator
-	 * @param string $customConfigDir
-	 * @param string $defaultConfigDir
-	 */
-	public function __construct(IURLGenerator $urlGenerator,
-								$customConfigDir,
-								$defaultConfigDir) {
-		$this->urlGenerator = $urlGenerator;
-		$this->customConfigDir = $customConfigDir;
-		$this->defaultConfigDir = $defaultConfigDir;
-	}
-
-	/**
-	 * Add an extension -> mimetype mapping
-	 *
-	 * $mimetype is the assumed correct mime type
-	 * The optional $secureMimeType is an alternative to send to send
-	 * to avoid potential XSS.
-	 *
-	 * @param string $extension
-	 * @param string $mimetype
-	 * @param string|null $secureMimeType
-	 */
-	public function registerType($extension,
-								 $mimetype,
-								 $secureMimeType = null) {
-		$this->mimetypes[$extension] = array($mimetype, $secureMimeType);
-		$this->secureMimeTypes[$mimetype] = $secureMimeType ?: $mimetype;
-	}
-
-	/**
-	 * Add an array of extension -> mimetype mappings
-	 *
-	 * The mimetype value is in itself an array where the first index is
-	 * the assumed correct mimetype and the second is either a secure alternative
-	 * or null if the correct is considered secure.
-	 *
-	 * @param array $types
-	 */
-	public function registerTypeArray($types) {
-		$this->mimetypes = array_merge($this->mimetypes, $types);
-
-		// Update the alternative mimetypes to avoid having to look them up each time.
-		foreach ($this->mimetypes as $mimeType) {
-			$this->secureMimeTypes[$mimeType[0]] = isset($mimeType[1]) ? $mimeType[1]: $mimeType[0];
-		}
-	}
-
-	/**
-	 * Add the mimetype aliases if they are not yet present
-	 */
-	private function loadAliases() {
-		if (!empty($this->mimeTypeAlias)) {
-			return;
-		}
-
-		$this->mimeTypeAlias = json_decode(file_get_contents($this->defaultConfigDir . '/mimetypealiases.dist.json'), true);
-
-		if (file_exists($this->customConfigDir . '/mimetypealiases.json')) {
-			$custom = json_decode(file_get_contents($this->customConfigDir . '/mimetypealiases.json'), true);
-			$this->mimeTypeAlias = array_merge($this->mimeTypeAlias, $custom);
-		}
-	}
-
-	/**
-	 * @return string[]
-	 */
-	public function getAllAliases() {
-		$this->loadAliases();
-		return $this->mimeTypeAlias;
-	}
-
-	/**
-	 * Add mimetype mappings if they are not yet present
-	 */
-	private function loadMappings() {
-		if (!empty($this->mimetypes)) {
-			return;
-		}
-
-		$mimetypeMapping = json_decode(file_get_contents($this->defaultConfigDir . '/mimetypemapping.dist.json'), true);
-
-		//Check if need to load custom mappings
-		if (file_exists($this->customConfigDir . '/mimetypemapping.json')) {
-			$custom = json_decode(file_get_contents($this->customConfigDir . '/mimetypemapping.json'), true);
-			$mimetypeMapping = array_merge($mimetypeMapping, $custom);
-		}
-
-		$this->registerTypeArray($mimetypeMapping);
-	}
-
-	/**
-	 * @return array
-	 */
-	public function getAllMappings() {
-		$this->loadMappings();
-		return $this->mimetypes;
-	}
-
-	/**
-	 * detect mimetype only based on filename, content of file is not used
-	 *
-	 * @param string $path
-	 * @return string
-	 */
-	public function detectPath($path) {
-		$this->loadMappings();
-
-		$fileName = basename($path);
-
-		// remove leading dot on hidden files with a file extension
-		$fileName = ltrim($fileName, '.');
-
-		// note: leading dot doesn't qualify as extension
-		if (strpos($fileName, '.') > 0) {
-
-			// remove versioning extension: name.v1508946057 and transfer extension: name.ocTransferId2057600214.part
-			$fileName = preg_replace('!((\.v\d+)|((.ocTransferId\d+)?.part))$!', '', $fileName);
-
-			//try to guess the type by the file extension
-			$extension = strtolower(strrchr($fileName, '.'));
-			$extension = substr($extension, 1); //remove leading .
-			return (isset($this->mimetypes[$extension]) && isset($this->mimetypes[$extension][0]))
-				? $this->mimetypes[$extension][0]
-				: 'application/octet-stream';
-		} else {
-			return 'application/octet-stream';
-		}
-	}
-
-	/**
-	 * detect mimetype based on both filename and content
-	 *
-	 * @param string $path
-	 * @return string
-	 */
-	public function detect($path) {
-		$this->loadMappings();
-
-		if (@is_dir($path)) {
-			// directories are easy
-			return "httpd/unix-directory";
-		}
-
-		$mimeType = $this->detectPath($path);
-
-		if ($mimeType === 'application/octet-stream' and function_exists('finfo_open')
-			and function_exists('finfo_file') and $finfo = finfo_open(FILEINFO_MIME)
-		) {
-			$info = @strtolower(finfo_file($finfo, $path));
-			finfo_close($finfo);
-			if ($info) {
-				$mimeType = strpos($info, ';') !== false ? substr($info, 0, strpos($info, ';')) : $info;
-				return empty($mimeType) ? 'application/octet-stream' : $mimeType;
-			}
-
-		}
-		$isWrapped = (strpos($path, '://') !== false) and (substr($path, 0, 7) === 'file://');
-		if (!$isWrapped and $mimeType === 'application/octet-stream' && function_exists("mime_content_type")) {
-			// use mime magic extension if available
-			$mimeType = mime_content_type($path);
-		}
-		if (!$isWrapped and $mimeType === 'application/octet-stream' && \OC_Helper::canExecute("file")) {
-			// it looks like we have a 'file' command,
-			// lets see if it does have mime support
-			$path = escapeshellarg($path);
-			$fp = popen("file -b --mime-type $path 2>/dev/null", "r");
-			$reply = fgets($fp);
-			pclose($fp);
-
-			//trim the newline
-			$mimeType = trim($reply);
-
-			if (empty($mimeType)) {
-				$mimeType = 'application/octet-stream';
-			}
-
-		}
-		return $mimeType;
-	}
-
-	/**
-	 * detect mimetype based on the content of a string
-	 *
-	 * @param string $data
-	 * @return string
-	 */
-	public function detectString($data) {
-		if (function_exists('finfo_open') and function_exists('finfo_file')) {
-			$finfo = finfo_open(FILEINFO_MIME);
-			$info = finfo_buffer($finfo, $data);
-			return strpos($info, ';') !== false ? substr($info, 0, strpos($info, ';')) : $info;
-		} else {
-			$tmpFile = \OC::$server->getTempManager()->getTemporaryFile();
-			$fh = fopen($tmpFile, 'wb');
-			fwrite($fh, $data, 8024);
-			fclose($fh);
-			$mime = $this->detect($tmpFile);
-			unset($tmpFile);
-			return $mime;
-		}
-	}
-
-	/**
-	 * Get a secure mimetype that won't expose potential XSS.
-	 *
-	 * @param string $mimeType
-	 * @return string
-	 */
-	public function getSecureMimeType($mimeType) {
-		$this->loadMappings();
-
-		return isset($this->secureMimeTypes[$mimeType])
-			? $this->secureMimeTypes[$mimeType]
-			: 'application/octet-stream';
-	}
-
-	/**
-	 * Get path to the icon of a file type
-	 * @param string $mimetype the MIME type
-	 * @return string the url
-	 */
-	public function mimeTypeIcon($mimetype) {
-		$this->loadAliases();
-
-		while (isset($this->mimeTypeAlias[$mimetype])) {
-			$mimetype = $this->mimeTypeAlias[$mimetype];
-		}
-		if (isset($this->mimetypeIcons[$mimetype])) {
-			return $this->mimetypeIcons[$mimetype];
-		}
-
-		// Replace slash and backslash with a minus
-		$icon = str_replace('/', '-', $mimetype);
-		$icon = str_replace('\\', '-', $icon);
-
-		// Is it a dir?
-		if ($mimetype === 'dir') {
-			$this->mimetypeIcons[$mimetype] = $this->urlGenerator->imagePath('core', 'filetypes/folder.svg');
-			return $this->mimetypeIcons[$mimetype];
-		}
-		if ($mimetype === 'dir-shared') {
-			$this->mimetypeIcons[$mimetype] = $this->urlGenerator->imagePath('core', 'filetypes/folder-shared.svg');
-			return $this->mimetypeIcons[$mimetype];
-		}
-		if ($mimetype === 'dir-external') {
-			$this->mimetypeIcons[$mimetype] = $this->urlGenerator->imagePath('core', 'filetypes/folder-external.svg');
-			return $this->mimetypeIcons[$mimetype];
-		}
-
-		// Icon exists?
-		try {
-			$this->mimetypeIcons[$mimetype] = $this->urlGenerator->imagePath('core', 'filetypes/' . $icon . '.svg');
-			return $this->mimetypeIcons[$mimetype];
-		} catch (\RuntimeException $e) {
-			// Specified image not found
-		}
-
-		// Try only the first part of the filetype
-		$mimePart = substr($icon, 0, strpos($icon, '-'));
-		try {
-			$this->mimetypeIcons[$mimetype] = $this->urlGenerator->imagePath('core', 'filetypes/' . $mimePart . '.svg');
-			return $this->mimetypeIcons[$mimetype];
-		} catch (\RuntimeException $e) {
-			// Image for the first part of the mimetype not found
-		}
-
-		$this->mimetypeIcons[$mimetype] = $this->urlGenerator->imagePath('core', 'filetypes/file.svg');
-		return $this->mimetypeIcons[$mimetype];
-	}
+    protected $mimetypes = [];
+    protected $secureMimeTypes = [];
+
+    protected $mimetypeIcons = [];
+    /** @var string[] */
+    protected $mimeTypeAlias = [];
+
+    /** @var IURLGenerator */
+    private $urlGenerator;
+
+    /** @var string */
+    private $customConfigDir;
+
+    /** @var string */
+    private $defaultConfigDir;
+
+    /**
+     * @param IURLGenerator $urlGenerator
+     * @param string $customConfigDir
+     * @param string $defaultConfigDir
+     */
+    public function __construct(IURLGenerator $urlGenerator,
+                                $customConfigDir,
+                                $defaultConfigDir) {
+        $this->urlGenerator = $urlGenerator;
+        $this->customConfigDir = $customConfigDir;
+        $this->defaultConfigDir = $defaultConfigDir;
+    }
+
+    /**
+     * Add an extension -> mimetype mapping
+     *
+     * $mimetype is the assumed correct mime type
+     * The optional $secureMimeType is an alternative to send to send
+     * to avoid potential XSS.
+     *
+     * @param string $extension
+     * @param string $mimetype
+     * @param string|null $secureMimeType
+     */
+    public function registerType($extension,
+                                    $mimetype,
+                                    $secureMimeType = null) {
+        $this->mimetypes[$extension] = array($mimetype, $secureMimeType);
+        $this->secureMimeTypes[$mimetype] = $secureMimeType ?: $mimetype;
+    }
+
+    /**
+     * Add an array of extension -> mimetype mappings
+     *
+     * The mimetype value is in itself an array where the first index is
+     * the assumed correct mimetype and the second is either a secure alternative
+     * or null if the correct is considered secure.
+     *
+     * @param array $types
+     */
+    public function registerTypeArray($types) {
+        $this->mimetypes = array_merge($this->mimetypes, $types);
+
+        // Update the alternative mimetypes to avoid having to look them up each time.
+        foreach ($this->mimetypes as $mimeType) {
+            $this->secureMimeTypes[$mimeType[0]] = isset($mimeType[1]) ? $mimeType[1]: $mimeType[0];
+        }
+    }
+
+    /**
+     * Add the mimetype aliases if they are not yet present
+     */
+    private function loadAliases() {
+        if (!empty($this->mimeTypeAlias)) {
+            return;
+        }
+
+        $this->mimeTypeAlias = json_decode(file_get_contents($this->defaultConfigDir . '/mimetypealiases.dist.json'), true);
+
+        if (file_exists($this->customConfigDir . '/mimetypealiases.json')) {
+            $custom = json_decode(file_get_contents($this->customConfigDir . '/mimetypealiases.json'), true);
+            $this->mimeTypeAlias = array_merge($this->mimeTypeAlias, $custom);
+        }
+    }
+
+    /**
+     * @return string[]
+     */
+    public function getAllAliases() {
+        $this->loadAliases();
+        return $this->mimeTypeAlias;
+    }
+
+    /**
+     * Add mimetype mappings if they are not yet present
+     */
+    private function loadMappings() {
+        if (!empty($this->mimetypes)) {
+            return;
+        }
+
+        $mimetypeMapping = json_decode(file_get_contents($this->defaultConfigDir . '/mimetypemapping.dist.json'), true);
+
+        //Check if need to load custom mappings
+        if (file_exists($this->customConfigDir . '/mimetypemapping.json')) {
+            $custom = json_decode(file_get_contents($this->customConfigDir . '/mimetypemapping.json'), true);
+            $mimetypeMapping = array_merge($mimetypeMapping, $custom);
+        }
+
+        $this->registerTypeArray($mimetypeMapping);
+    }
+
+    /**
+     * @return array
+     */
+    public function getAllMappings() {
+        $this->loadMappings();
+        return $this->mimetypes;
+    }
+
+    /**
+     * detect mimetype only based on filename, content of file is not used
+     *
+     * @param string $path
+     * @return string
+     */
+    public function detectPath($path) {
+        $this->loadMappings();
+
+        $fileName = basename($path);
+
+        // remove leading dot on hidden files with a file extension
+        $fileName = ltrim($fileName, '.');
+
+        // note: leading dot doesn't qualify as extension
+        if (strpos($fileName, '.') > 0) {
+
+            // remove versioning extension: name.v1508946057 and transfer extension: name.ocTransferId2057600214.part
+            $fileName = preg_replace('!((\.v\d+)|((.ocTransferId\d+)?.part))$!', '', $fileName);
+
+            //try to guess the type by the file extension
+            $extension = strtolower(strrchr($fileName, '.'));
+            $extension = substr($extension, 1); //remove leading .
+            return (isset($this->mimetypes[$extension]) && isset($this->mimetypes[$extension][0]))
+                ? $this->mimetypes[$extension][0]
+                : 'application/octet-stream';
+        } else {
+            return 'application/octet-stream';
+        }
+    }
+
+    /**
+     * detect mimetype based on both filename and content
+     *
+     * @param string $path
+     * @return string
+     */
+    public function detect($path) {
+        $this->loadMappings();
+
+        if (@is_dir($path)) {
+            // directories are easy
+            return "httpd/unix-directory";
+        }
+
+        $mimeType = $this->detectPath($path);
+
+        if ($mimeType === 'application/octet-stream' and function_exists('finfo_open')
+            and function_exists('finfo_file') and $finfo = finfo_open(FILEINFO_MIME)
+        ) {
+            $info = @strtolower(finfo_file($finfo, $path));
+            finfo_close($finfo);
+            if ($info) {
+                $mimeType = strpos($info, ';') !== false ? substr($info, 0, strpos($info, ';')) : $info;
+                return empty($mimeType) ? 'application/octet-stream' : $mimeType;
+            }
+
+        }
+        $isWrapped = (strpos($path, '://') !== false) and (substr($path, 0, 7) === 'file://');
+        if (!$isWrapped and $mimeType === 'application/octet-stream' && function_exists("mime_content_type")) {
+            // use mime magic extension if available
+            $mimeType = mime_content_type($path);
+        }
+        if (!$isWrapped and $mimeType === 'application/octet-stream' && \OC_Helper::canExecute("file")) {
+            // it looks like we have a 'file' command,
+            // lets see if it does have mime support
+            $path = escapeshellarg($path);
+            $fp = popen("file -b --mime-type $path 2>/dev/null", "r");
+            $reply = fgets($fp);
+            pclose($fp);
+
+            //trim the newline
+            $mimeType = trim($reply);
+
+            if (empty($mimeType)) {
+                $mimeType = 'application/octet-stream';
+            }
+
+        }
+        return $mimeType;
+    }
+
+    /**
+     * detect mimetype based on the content of a string
+     *
+     * @param string $data
+     * @return string
+     */
+    public function detectString($data) {
+        if (function_exists('finfo_open') and function_exists('finfo_file')) {
+            $finfo = finfo_open(FILEINFO_MIME);
+            $info = finfo_buffer($finfo, $data);
+            return strpos($info, ';') !== false ? substr($info, 0, strpos($info, ';')) : $info;
+        } else {
+            $tmpFile = \OC::$server->getTempManager()->getTemporaryFile();
+            $fh = fopen($tmpFile, 'wb');
+            fwrite($fh, $data, 8024);
+            fclose($fh);
+            $mime = $this->detect($tmpFile);
+            unset($tmpFile);
+            return $mime;
+        }
+    }
+
+    /**
+     * Get a secure mimetype that won't expose potential XSS.
+     *
+     * @param string $mimeType
+     * @return string
+     */
+    public function getSecureMimeType($mimeType) {
+        $this->loadMappings();
+
+        return isset($this->secureMimeTypes[$mimeType])
+            ? $this->secureMimeTypes[$mimeType]
+            : 'application/octet-stream';
+    }
+
+    /**
+     * Get path to the icon of a file type
+     * @param string $mimetype the MIME type
+     * @return string the url
+     */
+    public function mimeTypeIcon($mimetype) {
+        $this->loadAliases();
+
+        while (isset($this->mimeTypeAlias[$mimetype])) {
+            $mimetype = $this->mimeTypeAlias[$mimetype];
+        }
+        if (isset($this->mimetypeIcons[$mimetype])) {
+            return $this->mimetypeIcons[$mimetype];
+        }
+
+        // Replace slash and backslash with a minus
+        $icon = str_replace('/', '-', $mimetype);
+        $icon = str_replace('\\', '-', $icon);
+
+        // Is it a dir?
+        if ($mimetype === 'dir') {
+            $this->mimetypeIcons[$mimetype] = $this->urlGenerator->imagePath('core', 'filetypes/folder.svg');
+            return $this->mimetypeIcons[$mimetype];
+        }
+        if ($mimetype === 'dir-shared') {
+            $this->mimetypeIcons[$mimetype] = $this->urlGenerator->imagePath('core', 'filetypes/folder-shared.svg');
+            return $this->mimetypeIcons[$mimetype];
+        }
+        if ($mimetype === 'dir-external') {
+            $this->mimetypeIcons[$mimetype] = $this->urlGenerator->imagePath('core', 'filetypes/folder-external.svg');
+            return $this->mimetypeIcons[$mimetype];
+        }
+
+        // Icon exists?
+        try {
+            $this->mimetypeIcons[$mimetype] = $this->urlGenerator->imagePath('core', 'filetypes/' . $icon . '.svg');
+            return $this->mimetypeIcons[$mimetype];
+        } catch (\RuntimeException $e) {
+            // Specified image not found
+        }
+
+        // Try only the first part of the filetype
+        $mimePart = substr($icon, 0, strpos($icon, '-'));
+        try {
+            $this->mimetypeIcons[$mimetype] = $this->urlGenerator->imagePath('core', 'filetypes/' . $mimePart . '.svg');
+            return $this->mimetypeIcons[$mimetype];
+        } catch (\RuntimeException $e) {
+            // Image for the first part of the mimetype not found
+        }
+
+        $this->mimetypeIcons[$mimetype] = $this->urlGenerator->imagePath('core', 'filetypes/file.svg');
+        return $this->mimetypeIcons[$mimetype];
+    }
 }

lib/private/Files/Type/TemplateManager.php

Indentation +31 added lines, -31 removed lines

@@ -25,38 +25,38 @@
 namespace OC\Files\Type;
 
 class TemplateManager {
-	protected $templates = array();
+    protected $templates = array();
 
-	public function registerTemplate($mimetype, $path) {
-		$this->templates[$mimetype] = $path;
-	}
+    public function registerTemplate($mimetype, $path) {
+        $this->templates[$mimetype] = $path;
+    }
 
-	/**
-	 * get the path of the template for a mimetype
-	 *
-	 * @param string $mimetype
-	 * @return string|null
-	 */
-	public function getTemplatePath($mimetype) {
-		if (isset($this->templates[$mimetype])) {
-			return $this->templates[$mimetype];
-		} else {
-			return null;
-		}
-	}
+    /**
+     * get the path of the template for a mimetype
+     *
+     * @param string $mimetype
+     * @return string|null
+     */
+    public function getTemplatePath($mimetype) {
+        if (isset($this->templates[$mimetype])) {
+            return $this->templates[$mimetype];
+        } else {
+            return null;
+        }
+    }
 
-	/**
-	 * get the template content for a mimetype
-	 *
-	 * @param string $mimetype
-	 * @return string
-	 */
-	public function getTemplate($mimetype) {
-		$path = $this->getTemplatePath($mimetype);
-		if ($path) {
-			return file_get_contents($path);
-		} else {
-			return '';
-		}
-	}
+    /**
+     * get the template content for a mimetype
+     *
+     * @param string $mimetype
+     * @return string
+     */
+    public function getTemplate($mimetype) {
+        $path = $this->getTemplatePath($mimetype);
+        if ($path) {
+            return file_get_contents($path);
+        } else {
+            return '';
+        }
+    }
 }