nextcloud / server

lib/public/OCS/IDiscoveryService.php

Indentation +13 added lines, -13 removed lines

@@ -35,18 +35,18 @@
  */
 interface IDiscoveryService {
 
-	/**
-	 * Discover OCS end-points
-	 *
-	 * If no valid discovery data is found the defaults are returned
-	 *
-	 * @since 12.0.0
-	 *
-	 * @param string $remote
-	 * @param string $service the service you want to discover
-	 * @param bool $skipCache We won't check if the data is in the cache. This is useful if a background job is updating the status - Added in 14.0.0
-	 * @return array
-	 */
-	public function discover(string $remote, string $service, bool $skipCache = false): array;
+    /**
+     * Discover OCS end-points
+     *
+     * If no valid discovery data is found the defaults are returned
+     *
+     * @since 12.0.0
+     *
+     * @param string $remote
+     * @param string $service the service you want to discover
+     * @param bool $skipCache We won't check if the data is in the cache. This is useful if a background job is updating the status - Added in 14.0.0
+     * @return array
+     */
+    public function discover(string $remote, string $service, bool $skipCache = false): array;
 
 }

lib/private/Lock/DBLockingProvider.php

Spacing +2 added lines, -2 removed lines

@@ -154,7 +154,7 @@ 
 		}
 		$query = $this->connection->prepare('SELECT `lock` from `*PREFIX*file_locks` WHERE `key` = ?');
 		$query->execute([$path]);
-		$lockValue = (int)$query->fetchColumn();
+		$lockValue = (int) $query->fetchColumn();
 		if ($type === self::LOCK_SHARED) {
 			if ($this->isLocallyLocked($path)) {
 				// if we have a shared lock we kept open locally but it's released we always have at least 1 shared lock in the db
@@ -291,7 +291,7 @@ 
 		}
 		// since we keep shared locks we need to manually clean those
 		$lockedPaths = array_keys($this->sharedLocks);
-		$lockedPaths = array_filter($lockedPaths, function ($path) {
+		$lockedPaths = array_filter($lockedPaths, function($path) {
 			return $this->sharedLocks[$path];
 		});
 

Indentation +249 added lines, -249 removed lines

@@ -41,275 +41,275 @@
  * Locking provider that stores the locks in the database
  */
 class DBLockingProvider extends AbstractLockingProvider {
-	/**
-	 * @var \OCP\IDBConnection
-	 */
-	private $connection;
+    /**
+     * @var \OCP\IDBConnection
+     */
+    private $connection;
 
-	/**
-	 * @var \OCP\ILogger
-	 */
-	private $logger;
+    /**
+     * @var \OCP\ILogger
+     */
+    private $logger;
 
-	/**
-	 * @var \OCP\AppFramework\Utility\ITimeFactory
-	 */
-	private $timeFactory;
+    /**
+     * @var \OCP\AppFramework\Utility\ITimeFactory
+     */
+    private $timeFactory;
 
-	private $sharedLocks = [];
+    private $sharedLocks = [];
 
-	/**
-	 * @var bool
-	 */
-	private $cacheSharedLocks;
+    /**
+     * @var bool
+     */
+    private $cacheSharedLocks;
 
-	/**
-	 * Check if we have an open shared lock for a path
-	 *
-	 * @param string $path
-	 * @return bool
-	 */
-	protected function isLocallyLocked(string $path): bool {
-		return isset($this->sharedLocks[$path]) && $this->sharedLocks[$path];
-	}
+    /**
+     * Check if we have an open shared lock for a path
+     *
+     * @param string $path
+     * @return bool
+     */
+    protected function isLocallyLocked(string $path): bool {
+        return isset($this->sharedLocks[$path]) && $this->sharedLocks[$path];
+    }
 
-	/**
-	 * Mark a locally acquired lock
-	 *
-	 * @param string $path
-	 * @param int $type self::LOCK_SHARED or self::LOCK_EXCLUSIVE
-	 */
-	protected function markAcquire(string $path, int $type) {
-		parent::markAcquire($path, $type);
-		if ($this->cacheSharedLocks) {
-			if ($type === self::LOCK_SHARED) {
-				$this->sharedLocks[$path] = true;
-			}
-		}
-	}
+    /**
+     * Mark a locally acquired lock
+     *
+     * @param string $path
+     * @param int $type self::LOCK_SHARED or self::LOCK_EXCLUSIVE
+     */
+    protected function markAcquire(string $path, int $type) {
+        parent::markAcquire($path, $type);
+        if ($this->cacheSharedLocks) {
+            if ($type === self::LOCK_SHARED) {
+                $this->sharedLocks[$path] = true;
+            }
+        }
+    }
 
-	/**
-	 * Change the type of an existing tracked lock
-	 *
-	 * @param string $path
-	 * @param int $targetType self::LOCK_SHARED or self::LOCK_EXCLUSIVE
-	 */
-	protected function markChange(string $path, int $targetType) {
-		parent::markChange($path, $targetType);
-		if ($this->cacheSharedLocks) {
-			if ($targetType === self::LOCK_SHARED) {
-				$this->sharedLocks[$path] = true;
-			} elseif ($targetType === self::LOCK_EXCLUSIVE) {
-				$this->sharedLocks[$path] = false;
-			}
-		}
-	}
+    /**
+     * Change the type of an existing tracked lock
+     *
+     * @param string $path
+     * @param int $targetType self::LOCK_SHARED or self::LOCK_EXCLUSIVE
+     */
+    protected function markChange(string $path, int $targetType) {
+        parent::markChange($path, $targetType);
+        if ($this->cacheSharedLocks) {
+            if ($targetType === self::LOCK_SHARED) {
+                $this->sharedLocks[$path] = true;
+            } elseif ($targetType === self::LOCK_EXCLUSIVE) {
+                $this->sharedLocks[$path] = false;
+            }
+        }
+    }
 
-	/**
-	 * @param \OCP\IDBConnection $connection
-	 * @param \OCP\ILogger $logger
-	 * @param \OCP\AppFramework\Utility\ITimeFactory $timeFactory
-	 * @param int $ttl
-	 * @param bool $cacheSharedLocks
-	 */
-	public function __construct(
-		IDBConnection $connection,
-		ILogger $logger,
-		ITimeFactory $timeFactory,
-		int $ttl = 3600,
-		$cacheSharedLocks = true
-	) {
-		$this->connection = $connection;
-		$this->logger = $logger;
-		$this->timeFactory = $timeFactory;
-		$this->ttl = $ttl;
-		$this->cacheSharedLocks = $cacheSharedLocks;
-	}
+    /**
+     * @param \OCP\IDBConnection $connection
+     * @param \OCP\ILogger $logger
+     * @param \OCP\AppFramework\Utility\ITimeFactory $timeFactory
+     * @param int $ttl
+     * @param bool $cacheSharedLocks
+     */
+    public function __construct(
+        IDBConnection $connection,
+        ILogger $logger,
+        ITimeFactory $timeFactory,
+        int $ttl = 3600,
+        $cacheSharedLocks = true
+    ) {
+        $this->connection = $connection;
+        $this->logger = $logger;
+        $this->timeFactory = $timeFactory;
+        $this->ttl = $ttl;
+        $this->cacheSharedLocks = $cacheSharedLocks;
+    }
 
-	/**
-	 * Insert a file locking row if it does not exists.
-	 *
-	 * @param string $path
-	 * @param int $lock
-	 * @return int number of inserted rows
-	 */
-	protected function initLockField(string $path, int $lock = 0): int {
-		$expire = $this->getExpireTime();
-		return $this->connection->insertIgnoreConflict('file_locks', [
-			'key' => $path,
-			'lock' => $lock,
-			'ttl' => $expire
-		]);
-	}
+    /**
+     * Insert a file locking row if it does not exists.
+     *
+     * @param string $path
+     * @param int $lock
+     * @return int number of inserted rows
+     */
+    protected function initLockField(string $path, int $lock = 0): int {
+        $expire = $this->getExpireTime();
+        return $this->connection->insertIgnoreConflict('file_locks', [
+            'key' => $path,
+            'lock' => $lock,
+            'ttl' => $expire
+        ]);
+    }
 
-	/**
-	 * @return int
-	 */
-	protected function getExpireTime(): int {
-		return $this->timeFactory->getTime() + $this->ttl;
-	}
+    /**
+     * @return int
+     */
+    protected function getExpireTime(): int {
+        return $this->timeFactory->getTime() + $this->ttl;
+    }
 
-	/**
-	 * @param string $path
-	 * @param int $type self::LOCK_SHARED or self::LOCK_EXCLUSIVE
-	 * @return bool
-	 */
-	public function isLocked(string $path, int $type): bool {
-		if ($this->hasAcquiredLock($path, $type)) {
-			return true;
-		}
-		$query = $this->connection->prepare('SELECT `lock` from `*PREFIX*file_locks` WHERE `key` = ?');
-		$query->execute([$path]);
-		$lockValue = (int)$query->fetchColumn();
-		if ($type === self::LOCK_SHARED) {
-			if ($this->isLocallyLocked($path)) {
-				// if we have a shared lock we kept open locally but it's released we always have at least 1 shared lock in the db
-				return $lockValue > 1;
-			} else {
-				return $lockValue > 0;
-			}
-		} elseif ($type === self::LOCK_EXCLUSIVE) {
-			return $lockValue === -1;
-		} else {
-			return false;
-		}
-	}
+    /**
+     * @param string $path
+     * @param int $type self::LOCK_SHARED or self::LOCK_EXCLUSIVE
+     * @return bool
+     */
+    public function isLocked(string $path, int $type): bool {
+        if ($this->hasAcquiredLock($path, $type)) {
+            return true;
+        }
+        $query = $this->connection->prepare('SELECT `lock` from `*PREFIX*file_locks` WHERE `key` = ?');
+        $query->execute([$path]);
+        $lockValue = (int)$query->fetchColumn();
+        if ($type === self::LOCK_SHARED) {
+            if ($this->isLocallyLocked($path)) {
+                // if we have a shared lock we kept open locally but it's released we always have at least 1 shared lock in the db
+                return $lockValue > 1;
+            } else {
+                return $lockValue > 0;
+            }
+        } elseif ($type === self::LOCK_EXCLUSIVE) {
+            return $lockValue === -1;
+        } else {
+            return false;
+        }
+    }
 
-	/**
-	 * @param string $path
-	 * @param int $type self::LOCK_SHARED or self::LOCK_EXCLUSIVE
-	 * @throws \OCP\Lock\LockedException
-	 */
-	public function acquireLock(string $path, int $type, string $readablePath = null) {
-		$expire = $this->getExpireTime();
-		if ($type === self::LOCK_SHARED) {
-			if (!$this->isLocallyLocked($path)) {
-				$result = $this->initLockField($path, 1);
-				if ($result <= 0) {
-					$result = $this->connection->executeUpdate(
-						'UPDATE `*PREFIX*file_locks` SET `lock` = `lock` + 1, `ttl` = ? WHERE `key` = ? AND `lock` >= 0',
-						[$expire, $path]
-					);
-				}
-			} else {
-				$result = 1;
-			}
-		} else {
-			$existing = 0;
-			if ($this->hasAcquiredLock($path, ILockingProvider::LOCK_SHARED) === false && $this->isLocallyLocked($path)) {
-				$existing = 1;
-			}
-			$result = $this->initLockField($path, -1);
-			if ($result <= 0) {
-				$result = $this->connection->executeUpdate(
-					'UPDATE `*PREFIX*file_locks` SET `lock` = -1, `ttl` = ? WHERE `key` = ? AND `lock` = ?',
-					[$expire, $path, $existing]
-				);
-			}
-		}
-		if ($result !== 1) {
-			throw new LockedException($path, null, null, $readablePath);
-		}
-		$this->markAcquire($path, $type);
-	}
+    /**
+     * @param string $path
+     * @param int $type self::LOCK_SHARED or self::LOCK_EXCLUSIVE
+     * @throws \OCP\Lock\LockedException
+     */
+    public function acquireLock(string $path, int $type, string $readablePath = null) {
+        $expire = $this->getExpireTime();
+        if ($type === self::LOCK_SHARED) {
+            if (!$this->isLocallyLocked($path)) {
+                $result = $this->initLockField($path, 1);
+                if ($result <= 0) {
+                    $result = $this->connection->executeUpdate(
+                        'UPDATE `*PREFIX*file_locks` SET `lock` = `lock` + 1, `ttl` = ? WHERE `key` = ? AND `lock` >= 0',
+                        [$expire, $path]
+                    );
+                }
+            } else {
+                $result = 1;
+            }
+        } else {
+            $existing = 0;
+            if ($this->hasAcquiredLock($path, ILockingProvider::LOCK_SHARED) === false && $this->isLocallyLocked($path)) {
+                $existing = 1;
+            }
+            $result = $this->initLockField($path, -1);
+            if ($result <= 0) {
+                $result = $this->connection->executeUpdate(
+                    'UPDATE `*PREFIX*file_locks` SET `lock` = -1, `ttl` = ? WHERE `key` = ? AND `lock` = ?',
+                    [$expire, $path, $existing]
+                );
+            }
+        }
+        if ($result !== 1) {
+            throw new LockedException($path, null, null, $readablePath);
+        }
+        $this->markAcquire($path, $type);
+    }
 
-	/**
-	 * @param string $path
-	 * @param int $type self::LOCK_SHARED or self::LOCK_EXCLUSIVE
-	 */
-	public function releaseLock(string $path, int $type) {
-		$this->markRelease($path, $type);
+    /**
+     * @param string $path
+     * @param int $type self::LOCK_SHARED or self::LOCK_EXCLUSIVE
+     */
+    public function releaseLock(string $path, int $type) {
+        $this->markRelease($path, $type);
 
-		// we keep shared locks till the end of the request so we can re-use them
-		if ($type === self::LOCK_EXCLUSIVE) {
-			$this->connection->executeUpdate(
-				'UPDATE `*PREFIX*file_locks` SET `lock` = 0 WHERE `key` = ? AND `lock` = -1',
-				[$path]
-			);
-		} elseif (!$this->cacheSharedLocks) {
-			$query = $this->connection->getQueryBuilder();
-			$query->update('file_locks')
-				->set('lock', $query->func()->subtract('lock', $query->createNamedParameter(1)))
-				->where($query->expr()->eq('key', $query->createNamedParameter($path)))
-				->andWhere($query->expr()->gt('lock', $query->createNamedParameter(0)));
-			$query->execute();
-		}
-	}
+        // we keep shared locks till the end of the request so we can re-use them
+        if ($type === self::LOCK_EXCLUSIVE) {
+            $this->connection->executeUpdate(
+                'UPDATE `*PREFIX*file_locks` SET `lock` = 0 WHERE `key` = ? AND `lock` = -1',
+                [$path]
+            );
+        } elseif (!$this->cacheSharedLocks) {
+            $query = $this->connection->getQueryBuilder();
+            $query->update('file_locks')
+                ->set('lock', $query->func()->subtract('lock', $query->createNamedParameter(1)))
+                ->where($query->expr()->eq('key', $query->createNamedParameter($path)))
+                ->andWhere($query->expr()->gt('lock', $query->createNamedParameter(0)));
+            $query->execute();
+        }
+    }
 
-	/**
-	 * Change the type of an existing lock
-	 *
-	 * @param string $path
-	 * @param int $targetType self::LOCK_SHARED or self::LOCK_EXCLUSIVE
-	 * @throws \OCP\Lock\LockedException
-	 */
-	public function changeLock(string $path, int $targetType) {
-		$expire = $this->getExpireTime();
-		if ($targetType === self::LOCK_SHARED) {
-			$result = $this->connection->executeUpdate(
-				'UPDATE `*PREFIX*file_locks` SET `lock` = 1, `ttl` = ? WHERE `key` = ? AND `lock` = -1',
-				[$expire, $path]
-			);
-		} else {
-			// since we only keep one shared lock in the db we need to check if we have more then one shared lock locally manually
-			if (isset($this->acquiredLocks['shared'][$path]) && $this->acquiredLocks['shared'][$path] > 1) {
-				throw new LockedException($path);
-			}
-			$result = $this->connection->executeUpdate(
-				'UPDATE `*PREFIX*file_locks` SET `lock` = -1, `ttl` = ? WHERE `key` = ? AND `lock` = 1',
-				[$expire, $path]
-			);
-		}
-		if ($result !== 1) {
-			throw new LockedException($path);
-		}
-		$this->markChange($path, $targetType);
-	}
+    /**
+     * Change the type of an existing lock
+     *
+     * @param string $path
+     * @param int $targetType self::LOCK_SHARED or self::LOCK_EXCLUSIVE
+     * @throws \OCP\Lock\LockedException
+     */
+    public function changeLock(string $path, int $targetType) {
+        $expire = $this->getExpireTime();
+        if ($targetType === self::LOCK_SHARED) {
+            $result = $this->connection->executeUpdate(
+                'UPDATE `*PREFIX*file_locks` SET `lock` = 1, `ttl` = ? WHERE `key` = ? AND `lock` = -1',
+                [$expire, $path]
+            );
+        } else {
+            // since we only keep one shared lock in the db we need to check if we have more then one shared lock locally manually
+            if (isset($this->acquiredLocks['shared'][$path]) && $this->acquiredLocks['shared'][$path] > 1) {
+                throw new LockedException($path);
+            }
+            $result = $this->connection->executeUpdate(
+                'UPDATE `*PREFIX*file_locks` SET `lock` = -1, `ttl` = ? WHERE `key` = ? AND `lock` = 1',
+                [$expire, $path]
+            );
+        }
+        if ($result !== 1) {
+            throw new LockedException($path);
+        }
+        $this->markChange($path, $targetType);
+    }
 
-	/**
-	 * cleanup empty locks
-	 */
-	public function cleanExpiredLocks() {
-		$expire = $this->timeFactory->getTime();
-		try {
-			$this->connection->executeUpdate(
-				'DELETE FROM `*PREFIX*file_locks` WHERE `ttl` < ?',
-				[$expire]
-			);
-		} catch (\Exception $e) {
-			// If the table is missing, the clean up was successful
-			if ($this->connection->tableExists('file_locks')) {
-				throw $e;
-			}
-		}
-	}
+    /**
+     * cleanup empty locks
+     */
+    public function cleanExpiredLocks() {
+        $expire = $this->timeFactory->getTime();
+        try {
+            $this->connection->executeUpdate(
+                'DELETE FROM `*PREFIX*file_locks` WHERE `ttl` < ?',
+                [$expire]
+            );
+        } catch (\Exception $e) {
+            // If the table is missing, the clean up was successful
+            if ($this->connection->tableExists('file_locks')) {
+                throw $e;
+            }
+        }
+    }
 
-	/**
-	 * release all lock acquired by this instance which were marked using the mark* methods
-	 */
-	public function releaseAll() {
-		parent::releaseAll();
+    /**
+     * release all lock acquired by this instance which were marked using the mark* methods
+     */
+    public function releaseAll() {
+        parent::releaseAll();
 
-		if (!$this->cacheSharedLocks) {
-			return;
-		}
-		// since we keep shared locks we need to manually clean those
-		$lockedPaths = array_keys($this->sharedLocks);
-		$lockedPaths = array_filter($lockedPaths, function ($path) {
-			return $this->sharedLocks[$path];
-		});
+        if (!$this->cacheSharedLocks) {
+            return;
+        }
+        // since we keep shared locks we need to manually clean those
+        $lockedPaths = array_keys($this->sharedLocks);
+        $lockedPaths = array_filter($lockedPaths, function ($path) {
+            return $this->sharedLocks[$path];
+        });
 
-		$chunkedPaths = array_chunk($lockedPaths, 100);
+        $chunkedPaths = array_chunk($lockedPaths, 100);
 
-		foreach ($chunkedPaths as $chunk) {
-			$builder = $this->connection->getQueryBuilder();
+        foreach ($chunkedPaths as $chunk) {
+            $builder = $this->connection->getQueryBuilder();
 
-			$query = $builder->update('file_locks')
-				->set('lock', $builder->func()->subtract('lock', $builder->expr()->literal(1)))
-				->where($builder->expr()->in('key', $builder->createNamedParameter($chunk, IQueryBuilder::PARAM_STR_ARRAY)))
-				->andWhere($builder->expr()->gt('lock', new Literal(0)));
+            $query = $builder->update('file_locks')
+                ->set('lock', $builder->func()->subtract('lock', $builder->expr()->literal(1)))
+                ->where($builder->expr()->in('key', $builder->createNamedParameter($chunk, IQueryBuilder::PARAM_STR_ARRAY)))
+                ->andWhere($builder->expr()->gt('lock', new Literal(0)));
 
-			$query->execute();
-		}
-	}
+            $query->execute();
+        }
+    }
 }

core/Migrations/Version14000Date20180129121024.php

Indentation +22 added lines, -22 removed lines

@@ -30,30 +30,30 @@
  * Delete the admin|personal sections and settings tables
  */
 class Version14000Date20180129121024 extends SimpleMigrationStep {
-	public function name(): string {
-		return 'Drop obsolete settings tables';
-	}
+    public function name(): string {
+        return 'Drop obsolete settings tables';
+    }
 
-	public function description(): string {
-		return 'Drops the following obsolete tables: "admin_sections", "admin_settings", "personal_sections" and "personal_settings"';
-	}
+    public function description(): string {
+        return 'Drops the following obsolete tables: "admin_sections", "admin_settings", "personal_sections" and "personal_settings"';
+    }
 
-	/**
-	 * @param IOutput $output
-	 * @param \Closure $schemaClosure The `\Closure` returns a `ISchemaWrapper`
-	 * @param array $options
-	 * @return null|ISchemaWrapper
-	 * @since 13.0.0
-	 */
-	public function changeSchema(IOutput $output, \Closure $schemaClosure, array $options) {
-		/** @var ISchemaWrapper $schema */
-		$schema = $schemaClosure();
+    /**
+     * @param IOutput $output
+     * @param \Closure $schemaClosure The `\Closure` returns a `ISchemaWrapper`
+     * @param array $options
+     * @return null|ISchemaWrapper
+     * @since 13.0.0
+     */
+    public function changeSchema(IOutput $output, \Closure $schemaClosure, array $options) {
+        /** @var ISchemaWrapper $schema */
+        $schema = $schemaClosure();
 
-		$schema->dropTable('admin_sections');
-		$schema->dropTable('admin_settings');
-		$schema->dropTable('personal_sections');
-		$schema->dropTable('personal_settings');
+        $schema->dropTable('admin_sections');
+        $schema->dropTable('admin_settings');
+        $schema->dropTable('personal_sections');
+        $schema->dropTable('personal_settings');
 
-		return $schema;
-	}
+        return $schema;
+    }
 }

apps/dav/lib/Direct/Server.php

Indentation +5 added lines, -5 removed lines

@@ -25,9 +25,9 @@
 namespace OCA\DAV\Direct;
 
 class Server extends \Sabre\DAV\Server {
-	public function __construct($treeOrNode = null) {
-		parent::__construct($treeOrNode);
-		self::$exposeVersion = false;
-		$this->enablePropfindDepthInfinityf = false;
-	}
+    public function __construct($treeOrNode = null) {
+        parent::__construct($treeOrNode);
+        self::$exposeVersion = false;
+        $this->enablePropfindDepthInfinityf = false;
+    }
 }

apps/dav/lib/Db/Direct.php

Indentation +14 added lines, -14 removed lines

@@ -37,22 +37,22 @@
  * @method void setExpiration(int $expiration)
  */
 class Direct extends Entity {
-	/** @var string */
-	protected $userId;
+    /** @var string */
+    protected $userId;
 
-	/** @var int */
-	protected $fileId;
+    /** @var int */
+    protected $fileId;
 
-	/** @var string */
-	protected $token;
+    /** @var string */
+    protected $token;
 
-	/** @var int */
-	protected $expiration;
+    /** @var int */
+    protected $expiration;
 
-	public function __construct() {
-		$this->addType('userId', 'string');
-		$this->addType('fileId', 'int');
-		$this->addType('token', 'string');
-		$this->addType('expiration', 'int');
-	}
+    public function __construct() {
+        $this->addType('userId', 'string');
+        $this->addType('fileId', 'int');
+        $this->addType('token', 'string');
+        $this->addType('expiration', 'int');
+    }
 }

apps/files_external/lib/Service/LegacyStoragesService.php

Spacing +4 added lines, -4 removed lines

@@ -58,7 +58,7 @@ 
 	) {
 		$backend = $this->backendService->getBackend($storageOptions['backend']);
 		if (!$backend) {
-			throw new \UnexpectedValueException('Invalid backend ' . $storageOptions['backend']);
+			throw new \UnexpectedValueException('Invalid backend '.$storageOptions['backend']);
 		}
 		$storageConfig->setBackend($backend);
 		if (isset($storageOptions['authMechanism']) && $storageOptions['authMechanism'] !== 'builtin::builtin') {
@@ -68,7 +68,7 @@ 
 			$storageOptions['authMechanism'] = 'null'; // to make error handling easier
 		}
 		if (!$authMechanism) {
-			throw new \UnexpectedValueException('Invalid authentication mechanism ' . $storageOptions['authMechanism']);
+			throw new \UnexpectedValueException('Invalid authentication mechanism '.$storageOptions['authMechanism']);
 		}
 		$storageConfig->setAuthMechanism($authMechanism);
 		$storageConfig->setBackendOptions($storageOptions['options']);
@@ -140,7 +140,7 @@ 
 					$parts = explode('/', ltrim($rootMountPath, '/'), 3);
 					if (count($parts) < 3) {
 						// something went wrong, skip
-						\OC::$server->getLogger()->error('Could not parse mount point "' . $rootMountPath . '"', ['app' => 'files_external']);
+						\OC::$server->getLogger()->error('Could not parse mount point "'.$rootMountPath.'"', ['app' => 'files_external']);
 						continue;
 					}
 					$relativeMountPath = rtrim($parts[2], '/');
@@ -154,7 +154,7 @@ 
 						$storageOptions['authMechanism'] = null; // ensure config hash works
 					}
 					if (isset($storageOptions['id'])) {
-						$configId = (int)$storageOptions['id'];
+						$configId = (int) $storageOptions['id'];
 						if (isset($storages[$configId])) {
 							$currentStorage = $storages[$configId];
 						}

Indentation +171 added lines, -171 removed lines

@@ -34,179 +34,179 @@
  * Read mount config from legacy mount.json
  */
 abstract class LegacyStoragesService {
-	/** @var BackendService */
-	protected $backendService;
+    /** @var BackendService */
+    protected $backendService;
 
-	/**
-	 * Read legacy config data
-	 *
-	 * @return array list of mount configs
-	 */
-	abstract protected function readLegacyConfig();
+    /**
+     * Read legacy config data
+     *
+     * @return array list of mount configs
+     */
+    abstract protected function readLegacyConfig();
 
-	/**
-	 * Copy legacy storage options into the given storage config object.
-	 *
-	 * @param StorageConfig $storageConfig storage config to populate
-	 * @param string $mountType mount type
-	 * @param string $applicable applicable user or group
-	 * @param array $storageOptions legacy storage options
-	 *
-	 * @return StorageConfig populated storage config
-	 */
-	protected function populateStorageConfigWithLegacyOptions(
-		&$storageConfig,
-		$mountType,
-		$applicable,
-		$storageOptions
-	) {
-		$backend = $this->backendService->getBackend($storageOptions['backend']);
-		if (!$backend) {
-			throw new \UnexpectedValueException('Invalid backend ' . $storageOptions['backend']);
-		}
-		$storageConfig->setBackend($backend);
-		if (isset($storageOptions['authMechanism']) && $storageOptions['authMechanism'] !== 'builtin::builtin') {
-			$authMechanism = $this->backendService->getAuthMechanism($storageOptions['authMechanism']);
-		} else {
-			$authMechanism = $backend->getLegacyAuthMechanism($storageOptions);
-			$storageOptions['authMechanism'] = 'null'; // to make error handling easier
-		}
-		if (!$authMechanism) {
-			throw new \UnexpectedValueException('Invalid authentication mechanism ' . $storageOptions['authMechanism']);
-		}
-		$storageConfig->setAuthMechanism($authMechanism);
-		$storageConfig->setBackendOptions($storageOptions['options']);
-		if (isset($storageOptions['mountOptions'])) {
-			$storageConfig->setMountOptions($storageOptions['mountOptions']);
-		}
-		if (!isset($storageOptions['priority'])) {
-			$storageOptions['priority'] = $backend->getPriority();
-		}
-		$storageConfig->setPriority($storageOptions['priority']);
-		if ($mountType === \OCA\Files_External\MountConfig::MOUNT_TYPE_USER) {
-			$applicableUsers = $storageConfig->getApplicableUsers();
-			if ($applicable !== 'all') {
-				$applicableUsers[] = $applicable;
-				$storageConfig->setApplicableUsers($applicableUsers);
-			}
-		} elseif ($mountType === \OCA\Files_External\MountConfig::MOUNT_TYPE_GROUP) {
-			$applicableGroups = $storageConfig->getApplicableGroups();
-			$applicableGroups[] = $applicable;
-			$storageConfig->setApplicableGroups($applicableGroups);
-		}
-		return $storageConfig;
-	}
+    /**
+     * Copy legacy storage options into the given storage config object.
+     *
+     * @param StorageConfig $storageConfig storage config to populate
+     * @param string $mountType mount type
+     * @param string $applicable applicable user or group
+     * @param array $storageOptions legacy storage options
+     *
+     * @return StorageConfig populated storage config
+     */
+    protected function populateStorageConfigWithLegacyOptions(
+        &$storageConfig,
+        $mountType,
+        $applicable,
+        $storageOptions
+    ) {
+        $backend = $this->backendService->getBackend($storageOptions['backend']);
+        if (!$backend) {
+            throw new \UnexpectedValueException('Invalid backend ' . $storageOptions['backend']);
+        }
+        $storageConfig->setBackend($backend);
+        if (isset($storageOptions['authMechanism']) && $storageOptions['authMechanism'] !== 'builtin::builtin') {
+            $authMechanism = $this->backendService->getAuthMechanism($storageOptions['authMechanism']);
+        } else {
+            $authMechanism = $backend->getLegacyAuthMechanism($storageOptions);
+            $storageOptions['authMechanism'] = 'null'; // to make error handling easier
+        }
+        if (!$authMechanism) {
+            throw new \UnexpectedValueException('Invalid authentication mechanism ' . $storageOptions['authMechanism']);
+        }
+        $storageConfig->setAuthMechanism($authMechanism);
+        $storageConfig->setBackendOptions($storageOptions['options']);
+        if (isset($storageOptions['mountOptions'])) {
+            $storageConfig->setMountOptions($storageOptions['mountOptions']);
+        }
+        if (!isset($storageOptions['priority'])) {
+            $storageOptions['priority'] = $backend->getPriority();
+        }
+        $storageConfig->setPriority($storageOptions['priority']);
+        if ($mountType === \OCA\Files_External\MountConfig::MOUNT_TYPE_USER) {
+            $applicableUsers = $storageConfig->getApplicableUsers();
+            if ($applicable !== 'all') {
+                $applicableUsers[] = $applicable;
+                $storageConfig->setApplicableUsers($applicableUsers);
+            }
+        } elseif ($mountType === \OCA\Files_External\MountConfig::MOUNT_TYPE_GROUP) {
+            $applicableGroups = $storageConfig->getApplicableGroups();
+            $applicableGroups[] = $applicable;
+            $storageConfig->setApplicableGroups($applicableGroups);
+        }
+        return $storageConfig;
+    }
 
-	/**
-	 * Read the external storages config
-	 *
-	 * @return StorageConfig[] map of storage id to storage config
-	 */
-	public function getAllStorages() {
-		$mountPoints = $this->readLegacyConfig();
-		/**
-		 * Here is the how the horribly messy mount point array looks like
-		 * from the mount.json file:
-		 *
-		 * $storageOptions = $mountPoints[$mountType][$applicable][$mountPath]
-		 *
-		 * - $mountType is either "user" or "group"
-		 * - $applicable is the name of a user or group (or the current user for personal mounts)
-		 * - $mountPath is the mount point path (where the storage must be mounted)
-		 * - $storageOptions is a map of storage options:
-		 *     - "priority": storage priority
-		 *     - "backend": backend identifier
-		 *     - "class": LEGACY backend class name
-		 *     - "options": backend-specific options
-		 *     - "authMechanism": authentication mechanism identifier
-		 *     - "mountOptions": mount-specific options (ex: disable previews, scanner, etc)
-		 */
-		// group by storage id
-		/** @var StorageConfig[] $storages */
-		$storages = [];
-		// for storages without id (legacy), group by config hash for
-		// later processing
-		$storagesWithConfigHash = [];
-		foreach ($mountPoints as $mountType => $applicables) {
-			foreach ($applicables as $applicable => $mountPaths) {
-				foreach ($mountPaths as $rootMountPath => $storageOptions) {
-					$currentStorage = null;
-					/**
-					 * Flag whether the config that was read already has an id.
-					 * If not, it will use a config hash instead and generate
-					 * a proper id later
-					 *
-					 * @var boolean
-					 */
-					$hasId = false;
-					// the root mount point is in the format "/$user/files/the/mount/point"
-					// we remove the "/$user/files" prefix
-					$parts = explode('/', ltrim($rootMountPath, '/'), 3);
-					if (count($parts) < 3) {
-						// something went wrong, skip
-						\OC::$server->getLogger()->error('Could not parse mount point "' . $rootMountPath . '"', ['app' => 'files_external']);
-						continue;
-					}
-					$relativeMountPath = rtrim($parts[2], '/');
-					// note: we cannot do this after the loop because the decrypted config
-					// options might be needed for the config hash
-					$storageOptions['options'] = \OCA\Files_External\MountConfig::decryptPasswords($storageOptions['options']);
-					if (!isset($storageOptions['backend'])) {
-						$storageOptions['backend'] = $storageOptions['class']; // legacy compat
-					}
-					if (!isset($storageOptions['authMechanism'])) {
-						$storageOptions['authMechanism'] = null; // ensure config hash works
-					}
-					if (isset($storageOptions['id'])) {
-						$configId = (int)$storageOptions['id'];
-						if (isset($storages[$configId])) {
-							$currentStorage = $storages[$configId];
-						}
-						$hasId = true;
-					} else {
-						// missing id in legacy config, need to generate
-						// but at this point we don't know the max-id, so use
-						// first group it by config hash
-						$storageOptions['mountpoint'] = $rootMountPath;
-						$configId = \OCA\Files_External\MountConfig::makeConfigHash($storageOptions);
-						if (isset($storagesWithConfigHash[$configId])) {
-							$currentStorage = $storagesWithConfigHash[$configId];
-						}
-					}
-					if (is_null($currentStorage)) {
-						// create new
-						$currentStorage = new StorageConfig($configId);
-						$currentStorage->setMountPoint($relativeMountPath);
-					}
-					try {
-						$this->populateStorageConfigWithLegacyOptions(
-							$currentStorage,
-							$mountType,
-							$applicable,
-							$storageOptions
-						);
-						if ($hasId) {
-							$storages[$configId] = $currentStorage;
-						} else {
-							$storagesWithConfigHash[$configId] = $currentStorage;
-						}
-					} catch (\UnexpectedValueException $e) {
-						// don't die if a storage backend doesn't exist
-						\OC::$server->getLogger()->logException($e, [
-							'message' => 'Could not load storage.',
-							'level' => ILogger::ERROR,
-							'app' => 'files_external',
-						]);
-					}
-				}
-			}
-		}
+    /**
+     * Read the external storages config
+     *
+     * @return StorageConfig[] map of storage id to storage config
+     */
+    public function getAllStorages() {
+        $mountPoints = $this->readLegacyConfig();
+        /**
+         * Here is the how the horribly messy mount point array looks like
+         * from the mount.json file:
+         *
+         * $storageOptions = $mountPoints[$mountType][$applicable][$mountPath]
+         *
+         * - $mountType is either "user" or "group"
+         * - $applicable is the name of a user or group (or the current user for personal mounts)
+         * - $mountPath is the mount point path (where the storage must be mounted)
+         * - $storageOptions is a map of storage options:
+         *     - "priority": storage priority
+         *     - "backend": backend identifier
+         *     - "class": LEGACY backend class name
+         *     - "options": backend-specific options
+         *     - "authMechanism": authentication mechanism identifier
+         *     - "mountOptions": mount-specific options (ex: disable previews, scanner, etc)
+         */
+        // group by storage id
+        /** @var StorageConfig[] $storages */
+        $storages = [];
+        // for storages without id (legacy), group by config hash for
+        // later processing
+        $storagesWithConfigHash = [];
+        foreach ($mountPoints as $mountType => $applicables) {
+            foreach ($applicables as $applicable => $mountPaths) {
+                foreach ($mountPaths as $rootMountPath => $storageOptions) {
+                    $currentStorage = null;
+                    /**
+                     * Flag whether the config that was read already has an id.
+                     * If not, it will use a config hash instead and generate
+                     * a proper id later
+                     *
+                     * @var boolean
+                     */
+                    $hasId = false;
+                    // the root mount point is in the format "/$user/files/the/mount/point"
+                    // we remove the "/$user/files" prefix
+                    $parts = explode('/', ltrim($rootMountPath, '/'), 3);
+                    if (count($parts) < 3) {
+                        // something went wrong, skip
+                        \OC::$server->getLogger()->error('Could not parse mount point "' . $rootMountPath . '"', ['app' => 'files_external']);
+                        continue;
+                    }
+                    $relativeMountPath = rtrim($parts[2], '/');
+                    // note: we cannot do this after the loop because the decrypted config
+                    // options might be needed for the config hash
+                    $storageOptions['options'] = \OCA\Files_External\MountConfig::decryptPasswords($storageOptions['options']);
+                    if (!isset($storageOptions['backend'])) {
+                        $storageOptions['backend'] = $storageOptions['class']; // legacy compat
+                    }
+                    if (!isset($storageOptions['authMechanism'])) {
+                        $storageOptions['authMechanism'] = null; // ensure config hash works
+                    }
+                    if (isset($storageOptions['id'])) {
+                        $configId = (int)$storageOptions['id'];
+                        if (isset($storages[$configId])) {
+                            $currentStorage = $storages[$configId];
+                        }
+                        $hasId = true;
+                    } else {
+                        // missing id in legacy config, need to generate
+                        // but at this point we don't know the max-id, so use
+                        // first group it by config hash
+                        $storageOptions['mountpoint'] = $rootMountPath;
+                        $configId = \OCA\Files_External\MountConfig::makeConfigHash($storageOptions);
+                        if (isset($storagesWithConfigHash[$configId])) {
+                            $currentStorage = $storagesWithConfigHash[$configId];
+                        }
+                    }
+                    if (is_null($currentStorage)) {
+                        // create new
+                        $currentStorage = new StorageConfig($configId);
+                        $currentStorage->setMountPoint($relativeMountPath);
+                    }
+                    try {
+                        $this->populateStorageConfigWithLegacyOptions(
+                            $currentStorage,
+                            $mountType,
+                            $applicable,
+                            $storageOptions
+                        );
+                        if ($hasId) {
+                            $storages[$configId] = $currentStorage;
+                        } else {
+                            $storagesWithConfigHash[$configId] = $currentStorage;
+                        }
+                    } catch (\UnexpectedValueException $e) {
+                        // don't die if a storage backend doesn't exist
+                        \OC::$server->getLogger()->logException($e, [
+                            'message' => 'Could not load storage.',
+                            'level' => ILogger::ERROR,
+                            'app' => 'files_external',
+                        ]);
+                    }
+                }
+            }
+        }
 
-		// convert parameter values
-		foreach ($storages as $storage) {
-			$storage->getBackend()->validateStorageDefinition($storage);
-			$storage->getAuthMechanism()->validateStorageDefinition($storage);
-		}
-		return $storages;
-	}
+        // convert parameter values
+        foreach ($storages as $storage) {
+            $storage->getBackend()->validateStorageDefinition($storage);
+            $storage->getAuthMechanism()->validateStorageDefinition($storage);
+        }
+        return $storages;
+    }
 }

lib/public/Group/Backend/IGroupDetailsBackend.php

Indentation +4 added lines, -4 removed lines

@@ -29,8 +29,8 @@
  */
 interface IGroupDetailsBackend {
 
-	/**
-	 * @since 14.0.0
-	 */
-	public function getGroupDetails(string $gid): array;
+    /**
+     * @since 14.0.0
+     */
+    public function getGroupDetails(string $gid): array;
 }

lib/public/Group/Backend/IIsAdminBackend.php

Indentation +4 added lines, -4 removed lines

@@ -29,8 +29,8 @@
  */
 interface IIsAdminBackend {
 
-	/**
-	 * @since 14.0.0
-	 */
-	public function isAdmin(string $uid): bool;
+    /**
+     * @since 14.0.0
+     */
+    public function isAdmin(string $uid): bool;
 }

lib/public/Group/Backend/ICreateGroupBackend.php

Indentation +4 added lines, -4 removed lines

@@ -29,8 +29,8 @@
  */
 interface ICreateGroupBackend {
 
-	/**
-	 * @since 14.0.0
-	 */
-	public function createGroup(string $gid): bool;
+    /**
+     * @since 14.0.0
+     */
+    public function createGroup(string $gid): bool;
 }