nextcloud / server

apps/files_external/lib/Lib/Auth/OAuth1/OAuth1.php

Indentation +22 added lines, -22 removed lines

@@ -14,26 +14,26 @@
  * OAuth1 authentication
  */
 class OAuth1 extends AuthMechanism {
-	public function __construct(IL10N $l) {
-		$this
-			->setIdentifier('oauth1::oauth1')
-			->setScheme(self::SCHEME_OAUTH1)
-			->setText($l->t('OAuth1'))
-			->addParameters([
-				(new DefinitionParameter('configured', 'configured'))
-					->setType(DefinitionParameter::VALUE_TEXT)
-					->setFlag(DefinitionParameter::FLAG_HIDDEN),
-				new DefinitionParameter('app_key', $l->t('App key')),
-				(new DefinitionParameter('app_secret', $l->t('App secret')))
-					->setType(DefinitionParameter::VALUE_PASSWORD),
-				(new DefinitionParameter('token', 'token'))
-					->setType(DefinitionParameter::VALUE_PASSWORD)
-					->setFlag(DefinitionParameter::FLAG_HIDDEN),
-				(new DefinitionParameter('token_secret', 'token_secret'))
-					->setType(DefinitionParameter::VALUE_PASSWORD)
-					->setFlag(DefinitionParameter::FLAG_HIDDEN),
-			])
-			->addCustomJs('oauth1')
-		;
-	}
+    public function __construct(IL10N $l) {
+        $this
+            ->setIdentifier('oauth1::oauth1')
+            ->setScheme(self::SCHEME_OAUTH1)
+            ->setText($l->t('OAuth1'))
+            ->addParameters([
+                (new DefinitionParameter('configured', 'configured'))
+                    ->setType(DefinitionParameter::VALUE_TEXT)
+                    ->setFlag(DefinitionParameter::FLAG_HIDDEN),
+                new DefinitionParameter('app_key', $l->t('App key')),
+                (new DefinitionParameter('app_secret', $l->t('App secret')))
+                    ->setType(DefinitionParameter::VALUE_PASSWORD),
+                (new DefinitionParameter('token', 'token'))
+                    ->setType(DefinitionParameter::VALUE_PASSWORD)
+                    ->setFlag(DefinitionParameter::FLAG_HIDDEN),
+                (new DefinitionParameter('token_secret', 'token_secret'))
+                    ->setType(DefinitionParameter::VALUE_PASSWORD)
+                    ->setFlag(DefinitionParameter::FLAG_HIDDEN),
+            ])
+            ->addCustomJs('oauth1')
+        ;
+    }
 }

apps/files_external/lib/Lib/Auth/Password/LoginCredentials.php

Indentation +71 added lines, -71 removed lines

@@ -27,86 +27,86 @@
  * Username and password from login credentials, saved in DB
  */
 class LoginCredentials extends AuthMechanism {
-	public const CREDENTIALS_IDENTIFIER = 'password::logincredentials/credentials';
+    public const CREDENTIALS_IDENTIFIER = 'password::logincredentials/credentials';
 
-	public function __construct(
-		IL10N $l,
-		protected ISession $session,
-		protected ICredentialsManager $credentialsManager,
-		private CredentialsStore $credentialsStore,
-		IEventDispatcher $eventDispatcher,
-		private ILDAPProviderFactory $ldapFactory,
-	) {
-		$this
-			->setIdentifier('password::logincredentials')
-			->setScheme(self::SCHEME_PASSWORD)
-			->setText($l->t('Log-in credentials, save in database'))
-			->addParameters([
-				(new DefinitionParameter('password', $l->t('Password')))
-					->setType(DefinitionParameter::VALUE_PASSWORD)
-					->setFlag(DefinitionParameter::FLAG_HIDDEN)
-					->setFlag(DefinitionParameter::FLAG_OPTIONAL),
-			]);
+    public function __construct(
+        IL10N $l,
+        protected ISession $session,
+        protected ICredentialsManager $credentialsManager,
+        private CredentialsStore $credentialsStore,
+        IEventDispatcher $eventDispatcher,
+        private ILDAPProviderFactory $ldapFactory,
+    ) {
+        $this
+            ->setIdentifier('password::logincredentials')
+            ->setScheme(self::SCHEME_PASSWORD)
+            ->setText($l->t('Log-in credentials, save in database'))
+            ->addParameters([
+                (new DefinitionParameter('password', $l->t('Password')))
+                    ->setType(DefinitionParameter::VALUE_PASSWORD)
+                    ->setFlag(DefinitionParameter::FLAG_HIDDEN)
+                    ->setFlag(DefinitionParameter::FLAG_OPTIONAL),
+            ]);
 
-		$eventDispatcher->addServiceListener(UserLoggedInEvent::class, StorePasswordListener::class);
-		$eventDispatcher->addServiceListener(PasswordUpdatedEvent::class, StorePasswordListener::class);
-	}
+        $eventDispatcher->addServiceListener(UserLoggedInEvent::class, StorePasswordListener::class);
+        $eventDispatcher->addServiceListener(PasswordUpdatedEvent::class, StorePasswordListener::class);
+    }
 
-	private function getCredentials(IUser $user): array {
-		$credentials = $this->credentialsManager->retrieve($user->getUID(), self::CREDENTIALS_IDENTIFIER);
+    private function getCredentials(IUser $user): array {
+        $credentials = $this->credentialsManager->retrieve($user->getUID(), self::CREDENTIALS_IDENTIFIER);
 
-		if (is_null($credentials)) {
-			// nothing saved in db, try to get it from the session and save it
-			try {
-				$sessionCredentials = $this->credentialsStore->getLoginCredentials();
+        if (is_null($credentials)) {
+            // nothing saved in db, try to get it from the session and save it
+            try {
+                $sessionCredentials = $this->credentialsStore->getLoginCredentials();
 
-				if ($sessionCredentials->getUID() !== $user->getUID()) {
-					// Can't take the credentials from the session as they are not the same user
-					throw new CredentialsUnavailableException();
-				}
+                if ($sessionCredentials->getUID() !== $user->getUID()) {
+                    // Can't take the credentials from the session as they are not the same user
+                    throw new CredentialsUnavailableException();
+                }
 
-				$credentials = [
-					'user' => $sessionCredentials->getLoginName(),
-					'password' => $sessionCredentials->getPassword(),
-				];
+                $credentials = [
+                    'user' => $sessionCredentials->getLoginName(),
+                    'password' => $sessionCredentials->getPassword(),
+                ];
 
-				$this->credentialsManager->store($user->getUID(), self::CREDENTIALS_IDENTIFIER, $credentials);
-			} catch (CredentialsUnavailableException $e) {
-				throw new InsufficientDataForMeaningfulAnswerException('No login credentials saved');
-			}
-		}
+                $this->credentialsManager->store($user->getUID(), self::CREDENTIALS_IDENTIFIER, $credentials);
+            } catch (CredentialsUnavailableException $e) {
+                throw new InsufficientDataForMeaningfulAnswerException('No login credentials saved');
+            }
+        }
 
-		return $credentials;
-	}
+        return $credentials;
+    }
 
-	/**
-	 * @return void
-	 */
-	public function manipulateStorageConfig(StorageConfig &$storage, ?IUser $user = null) {
-		if (!isset($user)) {
-			throw new InsufficientDataForMeaningfulAnswerException('No login credentials saved');
-		}
-		$credentials = $this->getCredentials($user);
+    /**
+     * @return void
+     */
+    public function manipulateStorageConfig(StorageConfig &$storage, ?IUser $user = null) {
+        if (!isset($user)) {
+            throw new InsufficientDataForMeaningfulAnswerException('No login credentials saved');
+        }
+        $credentials = $this->getCredentials($user);
 
-		$loginKey = $storage->getBackendOption('login_ldap_attr');
-		if ($loginKey) {
-			$backend = $user->getBackend();
-			if ($backend instanceof IUserBackend && $backend->getBackendName() === 'LDAP') {
-				$value = $this->getLdapPropertyForUser($user, $loginKey);
-				if ($value === null) {
-					throw new InsufficientDataForMeaningfulAnswerException('Custom ldap attribute not set for user ' . $user->getUID());
-				}
-				$storage->setBackendOption('user', $value);
-			} else {
-				throw new InsufficientDataForMeaningfulAnswerException('Custom ldap attribute configured but user ' . $user->getUID() . ' is not an ldap user');
-			}
-		} else {
-			$storage->setBackendOption('user', $credentials['user']);
-		}
-		$storage->setBackendOption('password', $credentials['password']);
-	}
+        $loginKey = $storage->getBackendOption('login_ldap_attr');
+        if ($loginKey) {
+            $backend = $user->getBackend();
+            if ($backend instanceof IUserBackend && $backend->getBackendName() === 'LDAP') {
+                $value = $this->getLdapPropertyForUser($user, $loginKey);
+                if ($value === null) {
+                    throw new InsufficientDataForMeaningfulAnswerException('Custom ldap attribute not set for user ' . $user->getUID());
+                }
+                $storage->setBackendOption('user', $value);
+            } else {
+                throw new InsufficientDataForMeaningfulAnswerException('Custom ldap attribute configured but user ' . $user->getUID() . ' is not an ldap user');
+            }
+        } else {
+            $storage->setBackendOption('user', $credentials['user']);
+        }
+        $storage->setBackendOption('password', $credentials['password']);
+    }
 
-	private function getLdapPropertyForUser(IUser $user, string $property): ?string {
-		return $this->ldapFactory->getLDAPProvider()->getUserAttribute($user->getUID(), $property);
-	}
+    private function getLdapPropertyForUser(IUser $user, string $property): ?string {
+        return $this->ldapFactory->getLDAPProvider()->getUserAttribute($user->getUID(), $property);
+    }
 }

apps/files_external/lib/Lib/Auth/Password/SessionCredentials.php

Indentation +35 added lines, -35 removed lines

@@ -23,44 +23,44 @@
  */
 class SessionCredentials extends AuthMechanism {
 
-	public function __construct(
-		IL10N $l,
-		private CredentialsStore $credentialsStore,
-	) {
-		$this->setIdentifier('password::sessioncredentials')
-			->setScheme(self::SCHEME_PASSWORD)
-			->setText($l->t('Log-in credentials, save in session'))
-			->addParameters([
-				(new DefinitionParameter('password', $l->t('Password')))
-					->setType(DefinitionParameter::VALUE_PASSWORD)
-					->setFlag(DefinitionParameter::FLAG_HIDDEN)
-					->setFlag(DefinitionParameter::FLAG_OPTIONAL),
-			]);
-	}
+    public function __construct(
+        IL10N $l,
+        private CredentialsStore $credentialsStore,
+    ) {
+        $this->setIdentifier('password::sessioncredentials')
+            ->setScheme(self::SCHEME_PASSWORD)
+            ->setText($l->t('Log-in credentials, save in session'))
+            ->addParameters([
+                (new DefinitionParameter('password', $l->t('Password')))
+                    ->setType(DefinitionParameter::VALUE_PASSWORD)
+                    ->setFlag(DefinitionParameter::FLAG_HIDDEN)
+                    ->setFlag(DefinitionParameter::FLAG_OPTIONAL),
+            ]);
+    }
 
-	/**
-	 * @return void
-	 */
-	public function manipulateStorageConfig(StorageConfig &$storage, ?IUser $user = null) {
-		try {
-			$credentials = $this->credentialsStore->getLoginCredentials();
-		} catch (CredentialsUnavailableException $e) {
-			throw new InsufficientDataForMeaningfulAnswerException('No session credentials saved');
-		}
+    /**
+     * @return void
+     */
+    public function manipulateStorageConfig(StorageConfig &$storage, ?IUser $user = null) {
+        try {
+            $credentials = $this->credentialsStore->getLoginCredentials();
+        } catch (CredentialsUnavailableException $e) {
+            throw new InsufficientDataForMeaningfulAnswerException('No session credentials saved');
+        }
 
-		if ($user === null) {
-			throw new StorageAuthException('Session unavailable');
-		}
+        if ($user === null) {
+            throw new StorageAuthException('Session unavailable');
+        }
 
-		if ($credentials->getUID() !== $user->getUID()) {
-			throw new StorageAuthException('Session credentials for storage owner not available');
-		}
+        if ($credentials->getUID() !== $user->getUID()) {
+            throw new StorageAuthException('Session credentials for storage owner not available');
+        }
 
-		$storage->setBackendOption('user', $credentials->getLoginName());
-		$storage->setBackendOption('password', $credentials->getPassword());
-	}
+        $storage->setBackendOption('user', $credentials->getLoginName());
+        $storage->setBackendOption('password', $credentials->getPassword());
+    }
 
-	public function wrapStorage(IStorage $storage): IStorage {
-		return new SessionStorageWrapper(['storage' => $storage]);
-	}
+    public function wrapStorage(IStorage $storage): IStorage {
+        return new SessionStorageWrapper(['storage' => $storage]);
+    }
 }

apps/files_external/lib/Lib/Auth/PublicKey/RSA.php

Indentation +48 added lines, -48 removed lines

@@ -19,56 +19,56 @@
  */
 class RSA extends AuthMechanism {
 
-	public function __construct(
-		IL10N $l,
-		private IConfig $config,
-	) {
-		$this
-			->setIdentifier('publickey::rsa')
-			->setScheme(self::SCHEME_PUBLICKEY)
-			->setText($l->t('RSA public key'))
-			->addParameters([
-				new DefinitionParameter('user', $l->t('Login')),
-				new DefinitionParameter('public_key', $l->t('Public key')),
-				(new DefinitionParameter('private_key', 'private_key'))
-					->setType(DefinitionParameter::VALUE_PASSWORD)
-					->setFlag(DefinitionParameter::FLAG_HIDDEN),
-			])
-			->addCustomJs('public_key')
-		;
-	}
+    public function __construct(
+        IL10N $l,
+        private IConfig $config,
+    ) {
+        $this
+            ->setIdentifier('publickey::rsa')
+            ->setScheme(self::SCHEME_PUBLICKEY)
+            ->setText($l->t('RSA public key'))
+            ->addParameters([
+                new DefinitionParameter('user', $l->t('Login')),
+                new DefinitionParameter('public_key', $l->t('Public key')),
+                (new DefinitionParameter('private_key', 'private_key'))
+                    ->setType(DefinitionParameter::VALUE_PASSWORD)
+                    ->setFlag(DefinitionParameter::FLAG_HIDDEN),
+            ])
+            ->addCustomJs('public_key')
+        ;
+    }
 
-	/**
-	 * @return void
-	 */
-	public function manipulateStorageConfig(StorageConfig &$storage, ?IUser $user = null) {
-		$auth = new RSACrypt();
-		$auth->setPassword($this->config->getSystemValue('secret', ''));
-		if (!$auth->loadKey($storage->getBackendOption('private_key'))) {
-			// Add fallback routine for a time where secret was not enforced to be exists
-			$auth->setPassword('');
-			if (!$auth->loadKey($storage->getBackendOption('private_key'))) {
-				throw new \RuntimeException('unable to load private key');
-			}
-		}
-		$storage->setBackendOption('public_key_auth', $auth);
-	}
+    /**
+     * @return void
+     */
+    public function manipulateStorageConfig(StorageConfig &$storage, ?IUser $user = null) {
+        $auth = new RSACrypt();
+        $auth->setPassword($this->config->getSystemValue('secret', ''));
+        if (!$auth->loadKey($storage->getBackendOption('private_key'))) {
+            // Add fallback routine for a time where secret was not enforced to be exists
+            $auth->setPassword('');
+            if (!$auth->loadKey($storage->getBackendOption('private_key'))) {
+                throw new \RuntimeException('unable to load private key');
+            }
+        }
+        $storage->setBackendOption('public_key_auth', $auth);
+    }
 
-	/**
-	 * Generate a keypair
-	 *
-	 * @param int $keyLenth
-	 * @return array ['privatekey' => $privateKey, 'publickey' => $publicKey]
-	 */
-	public function createKey($keyLength) {
-		$rsa = new RSACrypt();
-		$rsa->setPublicKeyFormat(RSACrypt::PUBLIC_FORMAT_OPENSSH);
-		$rsa->setPassword($this->config->getSystemValue('secret', ''));
+    /**
+     * Generate a keypair
+     *
+     * @param int $keyLenth
+     * @return array ['privatekey' => $privateKey, 'publickey' => $publicKey]
+     */
+    public function createKey($keyLength) {
+        $rsa = new RSACrypt();
+        $rsa->setPublicKeyFormat(RSACrypt::PUBLIC_FORMAT_OPENSSH);
+        $rsa->setPassword($this->config->getSystemValue('secret', ''));
 
-		if ($keyLength !== 1024 && $keyLength !== 2048 && $keyLength !== 4096) {
-			$keyLength = 1024;
-		}
+        if ($keyLength !== 1024 && $keyLength !== 2048 && $keyLength !== 4096) {
+            $keyLength = 1024;
+        }
 
-		return $rsa->createKey($keyLength);
-	}
+        return $rsa->createKey($keyLength);
+    }
 }

apps/files_external/lib/Lib/Auth/OAuth2/OAuth2.php

Indentation +19 added lines, -19 removed lines

@@ -14,23 +14,23 @@
  * OAuth2 authentication
  */
 class OAuth2 extends AuthMechanism {
-	public function __construct(IL10N $l) {
-		$this
-			->setIdentifier('oauth2::oauth2')
-			->setScheme(self::SCHEME_OAUTH2)
-			->setText($l->t('OAuth2'))
-			->addParameters([
-				(new DefinitionParameter('configured', 'configured'))
-					->setType(DefinitionParameter::VALUE_TEXT)
-					->setFlag(DefinitionParameter::FLAG_HIDDEN),
-				new DefinitionParameter('client_id', $l->t('Client ID')),
-				(new DefinitionParameter('client_secret', $l->t('Client secret')))
-					->setType(DefinitionParameter::VALUE_PASSWORD),
-				(new DefinitionParameter('token', 'token'))
-					->setType(DefinitionParameter::VALUE_PASSWORD)
-					->setFlag(DefinitionParameter::FLAG_HIDDEN),
-			])
-			->addCustomJs('oauth2')
-		;
-	}
+    public function __construct(IL10N $l) {
+        $this
+            ->setIdentifier('oauth2::oauth2')
+            ->setScheme(self::SCHEME_OAUTH2)
+            ->setText($l->t('OAuth2'))
+            ->addParameters([
+                (new DefinitionParameter('configured', 'configured'))
+                    ->setType(DefinitionParameter::VALUE_TEXT)
+                    ->setFlag(DefinitionParameter::FLAG_HIDDEN),
+                new DefinitionParameter('client_id', $l->t('Client ID')),
+                (new DefinitionParameter('client_secret', $l->t('Client secret')))
+                    ->setType(DefinitionParameter::VALUE_PASSWORD),
+                (new DefinitionParameter('token', 'token'))
+                    ->setType(DefinitionParameter::VALUE_PASSWORD)
+                    ->setFlag(DefinitionParameter::FLAG_HIDDEN),
+            ])
+            ->addCustomJs('oauth2')
+        ;
+    }
 }

apps/files_external/lib/Lib/DefinitionParameter.php

Indentation +203 added lines, -203 removed lines

@@ -10,207 +10,207 @@
  * Parameter for an external storage definition
  */
 class DefinitionParameter implements \JsonSerializable {
-	// placeholder value for password fields, when the client updates a storage configuration
-	// placeholder values are ignored and the field is left unmodified
-	public const UNMODIFIED_PLACEHOLDER = '__unmodified__';
-
-	/** Value constants */
-	public const VALUE_TEXT = 0;
-	public const VALUE_BOOLEAN = 1;
-	public const VALUE_PASSWORD = 2;
-
-	/** Flag constants */
-	public const FLAG_NONE = 0;
-	public const FLAG_OPTIONAL = 1;
-	public const FLAG_USER_PROVIDED = 2;
-	public const FLAG_HIDDEN = 4;
-
-	/** @var string human-readable parameter tooltip */
-	private string $tooltip = '';
-
-	/** @var int value type, see self::VALUE_* constants */
-	private int $type = self::VALUE_TEXT;
-
-	/** @var int flags, see self::FLAG_* constants */
-	private int $flags = self::FLAG_NONE;
-
-	/**
-	 * @param string $name parameter name
-	 * @param string $text parameter description
-	 * @param mixed $defaultValue default value
-	 */
-	public function __construct(
-		private string $name,
-		private string $text,
-		private $defaultValue = null,
-	) {
-	}
-
-	/**
-	 * @return string
-	 */
-	public function getName(): string {
-		return $this->name;
-	}
-
-	/**
-	 * @return string
-	 */
-	public function getText(): string {
-		return $this->text;
-	}
-
-	/**
-	 * Get value type
-	 *
-	 * @return int
-	 */
-	public function getType(): int {
-		return $this->type;
-	}
-
-	/**
-	 * Set value type
-	 *
-	 * @param int $type
-	 * @return self
-	 */
-	public function setType(int $type) {
-		$this->type = $type;
-		return $this;
-	}
-
-	/**
-	 * @return mixed default value
-	 */
-	public function getDefaultValue() {
-		return $this->defaultValue;
-	}
-
-	/**
-	 * @param mixed $defaultValue default value
-	 * @return self
-	 */
-	public function setDefaultValue($defaultValue) {
-		$this->defaultValue = $defaultValue;
-		return $this;
-	}
-
-	/**
-	 * @return string
-	 */
-	public function getTypeName(): string {
-		switch ($this->type) {
-			case self::VALUE_BOOLEAN:
-				return 'boolean';
-			case self::VALUE_TEXT:
-				return 'text';
-			case self::VALUE_PASSWORD:
-				return 'password';
-			default:
-				return 'unknown';
-		}
-	}
-
-	/**
-	 * @return int
-	 */
-	public function getFlags(): int {
-		return $this->flags;
-	}
-
-	/**
-	 * @param int $flags
-	 * @return self
-	 */
-	public function setFlags(int $flags) {
-		$this->flags = $flags;
-		return $this;
-	}
-
-	/**
-	 * @param int $flag
-	 * @return self
-	 */
-	public function setFlag(int $flag) {
-		$this->flags |= $flag;
-		return $this;
-	}
-
-	/**
-	 * @param int $flag
-	 * @return bool
-	 */
-	public function isFlagSet(int $flag): bool {
-		return (bool)($this->flags & $flag);
-	}
-
-	/**
-	 * @return string
-	 */
-	public function getTooltip(): string {
-		return $this->tooltip;
-	}
-
-	/**
-	 * @param string $tooltip
-	 * @return self
-	 */
-	public function setTooltip(string $tooltip) {
-		$this->tooltip = $tooltip;
-		return $this;
-	}
-
-	/**
-	 * Serialize into JSON for client-side JS
-	 */
-	public function jsonSerialize(): array {
-		$result = [
-			'value' => $this->getText(),
-			'flags' => $this->getFlags(),
-			'type' => $this->getType(),
-			'tooltip' => $this->getTooltip(),
-		];
-		$defaultValue = $this->getDefaultValue();
-		if ($defaultValue) {
-			$result['defaultValue'] = $defaultValue;
-		}
-		return $result;
-	}
-
-	public function isOptional(): bool {
-		return $this->isFlagSet(self::FLAG_OPTIONAL) || $this->isFlagSet(self::FLAG_USER_PROVIDED);
-	}
-
-	/**
-	 * Validate a parameter value against this
-	 * Convert type as necessary
-	 *
-	 * @param mixed $value Value to check
-	 * @return bool success
-	 */
-	public function validateValue(&$value): bool {
-		switch ($this->getType()) {
-			case self::VALUE_BOOLEAN:
-				if (!is_bool($value)) {
-					switch ($value) {
-						case 'true':
-							$value = true;
-							break;
-						case 'false':
-							$value = false;
-							break;
-						default:
-							return false;
-					}
-				}
-				break;
-			default:
-				if (!$value && !$this->isOptional()) {
-					return false;
-				}
-				break;
-		}
-		return true;
-	}
+    // placeholder value for password fields, when the client updates a storage configuration
+    // placeholder values are ignored and the field is left unmodified
+    public const UNMODIFIED_PLACEHOLDER = '__unmodified__';
+
+    /** Value constants */
+    public const VALUE_TEXT = 0;
+    public const VALUE_BOOLEAN = 1;
+    public const VALUE_PASSWORD = 2;
+
+    /** Flag constants */
+    public const FLAG_NONE = 0;
+    public const FLAG_OPTIONAL = 1;
+    public const FLAG_USER_PROVIDED = 2;
+    public const FLAG_HIDDEN = 4;
+
+    /** @var string human-readable parameter tooltip */
+    private string $tooltip = '';
+
+    /** @var int value type, see self::VALUE_* constants */
+    private int $type = self::VALUE_TEXT;
+
+    /** @var int flags, see self::FLAG_* constants */
+    private int $flags = self::FLAG_NONE;
+
+    /**
+     * @param string $name parameter name
+     * @param string $text parameter description
+     * @param mixed $defaultValue default value
+     */
+    public function __construct(
+        private string $name,
+        private string $text,
+        private $defaultValue = null,
+    ) {
+    }
+
+    /**
+     * @return string
+     */
+    public function getName(): string {
+        return $this->name;
+    }
+
+    /**
+     * @return string
+     */
+    public function getText(): string {
+        return $this->text;
+    }
+
+    /**
+     * Get value type
+     *
+     * @return int
+     */
+    public function getType(): int {
+        return $this->type;
+    }
+
+    /**
+     * Set value type
+     *
+     * @param int $type
+     * @return self
+     */
+    public function setType(int $type) {
+        $this->type = $type;
+        return $this;
+    }
+
+    /**
+     * @return mixed default value
+     */
+    public function getDefaultValue() {
+        return $this->defaultValue;
+    }
+
+    /**
+     * @param mixed $defaultValue default value
+     * @return self
+     */
+    public function setDefaultValue($defaultValue) {
+        $this->defaultValue = $defaultValue;
+        return $this;
+    }
+
+    /**
+     * @return string
+     */
+    public function getTypeName(): string {
+        switch ($this->type) {
+            case self::VALUE_BOOLEAN:
+                return 'boolean';
+            case self::VALUE_TEXT:
+                return 'text';
+            case self::VALUE_PASSWORD:
+                return 'password';
+            default:
+                return 'unknown';
+        }
+    }
+
+    /**
+     * @return int
+     */
+    public function getFlags(): int {
+        return $this->flags;
+    }
+
+    /**
+     * @param int $flags
+     * @return self
+     */
+    public function setFlags(int $flags) {
+        $this->flags = $flags;
+        return $this;
+    }
+
+    /**
+     * @param int $flag
+     * @return self
+     */
+    public function setFlag(int $flag) {
+        $this->flags |= $flag;
+        return $this;
+    }
+
+    /**
+     * @param int $flag
+     * @return bool
+     */
+    public function isFlagSet(int $flag): bool {
+        return (bool)($this->flags & $flag);
+    }
+
+    /**
+     * @return string
+     */
+    public function getTooltip(): string {
+        return $this->tooltip;
+    }
+
+    /**
+     * @param string $tooltip
+     * @return self
+     */
+    public function setTooltip(string $tooltip) {
+        $this->tooltip = $tooltip;
+        return $this;
+    }
+
+    /**
+     * Serialize into JSON for client-side JS
+     */
+    public function jsonSerialize(): array {
+        $result = [
+            'value' => $this->getText(),
+            'flags' => $this->getFlags(),
+            'type' => $this->getType(),
+            'tooltip' => $this->getTooltip(),
+        ];
+        $defaultValue = $this->getDefaultValue();
+        if ($defaultValue) {
+            $result['defaultValue'] = $defaultValue;
+        }
+        return $result;
+    }
+
+    public function isOptional(): bool {
+        return $this->isFlagSet(self::FLAG_OPTIONAL) || $this->isFlagSet(self::FLAG_USER_PROVIDED);
+    }
+
+    /**
+     * Validate a parameter value against this
+     * Convert type as necessary
+     *
+     * @param mixed $value Value to check
+     * @return bool success
+     */
+    public function validateValue(&$value): bool {
+        switch ($this->getType()) {
+            case self::VALUE_BOOLEAN:
+                if (!is_bool($value)) {
+                    switch ($value) {
+                        case 'true':
+                            $value = true;
+                            break;
+                        case 'false':
+                            $value = false;
+                            break;
+                        default:
+                            return false;
+                    }
+                }
+                break;
+            default:
+                if (!$value && !$this->isOptional()) {
+                    return false;
+                }
+                break;
+        }
+        return true;
+    }
 }

apps/files_external/lib/Lib/Backend/LegacyBackend.php

Indentation +59 added lines, -59 removed lines

@@ -15,68 +15,68 @@
  * Legacy compatibility for OCA\Files_External\MountConfig::registerBackend()
  */
 class LegacyBackend extends Backend {
-	use LegacyDependencyCheckPolyfill {
-		LegacyDependencyCheckPolyfill::checkDependencies as doCheckDependencies;
-	}
+    use LegacyDependencyCheckPolyfill {
+        LegacyDependencyCheckPolyfill::checkDependencies as doCheckDependencies;
+    }
 
-	/** @var bool */
-	protected $hasDependencies = false;
+    /** @var bool */
+    protected $hasDependencies = false;
 
-	/**
-	 * @param string $class
-	 * @param array $definition
-	 * @param Builtin $authMechanism
-	 */
-	public function __construct($class, array $definition, Builtin $authMechanism) {
-		$this
-			->setIdentifier($class)
-			->setStorageClass($class)
-			->setText($definition['backend'])
-			->addAuthScheme(Builtin::SCHEME_BUILTIN)
-			->setLegacyAuthMechanism($authMechanism)
-		;
+    /**
+     * @param string $class
+     * @param array $definition
+     * @param Builtin $authMechanism
+     */
+    public function __construct($class, array $definition, Builtin $authMechanism) {
+        $this
+            ->setIdentifier($class)
+            ->setStorageClass($class)
+            ->setText($definition['backend'])
+            ->addAuthScheme(Builtin::SCHEME_BUILTIN)
+            ->setLegacyAuthMechanism($authMechanism)
+        ;
 
-		foreach ($definition['configuration'] as $name => $placeholder) {
-			$flags = DefinitionParameter::FLAG_NONE;
-			$type = DefinitionParameter::VALUE_TEXT;
-			if ($placeholder[0] === '&') {
-				$flags = DefinitionParameter::FLAG_OPTIONAL;
-				$placeholder = substr($placeholder, 1);
-			}
-			switch ($placeholder[0]) {
-				case '!':
-					$type = DefinitionParameter::VALUE_BOOLEAN;
-					$placeholder = substr($placeholder, 1);
-					break;
-				case '*':
-					$type = DefinitionParameter::VALUE_PASSWORD;
-					$placeholder = substr($placeholder, 1);
-					break;
-			}
-			$this->addParameter((new DefinitionParameter($name, $placeholder))
-				->setType($type)
-				->setFlags($flags)
-			);
-		}
+        foreach ($definition['configuration'] as $name => $placeholder) {
+            $flags = DefinitionParameter::FLAG_NONE;
+            $type = DefinitionParameter::VALUE_TEXT;
+            if ($placeholder[0] === '&') {
+                $flags = DefinitionParameter::FLAG_OPTIONAL;
+                $placeholder = substr($placeholder, 1);
+            }
+            switch ($placeholder[0]) {
+                case '!':
+                    $type = DefinitionParameter::VALUE_BOOLEAN;
+                    $placeholder = substr($placeholder, 1);
+                    break;
+                case '*':
+                    $type = DefinitionParameter::VALUE_PASSWORD;
+                    $placeholder = substr($placeholder, 1);
+                    break;
+            }
+            $this->addParameter((new DefinitionParameter($name, $placeholder))
+                ->setType($type)
+                ->setFlags($flags)
+            );
+        }
 
-		if (isset($definition['priority'])) {
-			$this->setPriority($definition['priority']);
-		}
-		if (isset($definition['custom'])) {
-			$this->addCustomJs($definition['custom']);
-		}
-		if (isset($definition['has_dependencies']) && $definition['has_dependencies']) {
-			$this->hasDependencies = true;
-		}
-	}
+        if (isset($definition['priority'])) {
+            $this->setPriority($definition['priority']);
+        }
+        if (isset($definition['custom'])) {
+            $this->addCustomJs($definition['custom']);
+        }
+        if (isset($definition['has_dependencies']) && $definition['has_dependencies']) {
+            $this->hasDependencies = true;
+        }
+    }
 
-	/**
-	 * @return MissingDependency[]
-	 */
-	public function checkDependencies() {
-		if ($this->hasDependencies) {
-			return $this->doCheckDependencies();
-		}
-		return [];
-	}
+    /**
+     * @return MissingDependency[]
+     */
+    public function checkDependencies() {
+        if ($this->hasDependencies) {
+            return $this->doCheckDependencies();
+        }
+        return [];
+    }
 }

apps/files_external/lib/Lib/Backend/SMB.php

Indentation +96 added lines, -96 removed lines

@@ -21,105 +21,105 @@
 use OCP\IUser;
 
 class SMB extends Backend {
-	use LegacyDependencyCheckPolyfill;
+    use LegacyDependencyCheckPolyfill;
 
-	public function __construct(IL10N $l, Password $legacyAuth) {
-		$this
-			->setIdentifier('smb')
-			->addIdentifierAlias('\OC\Files\Storage\SMB')// legacy compat
-			->setStorageClass('\OCA\Files_External\Lib\Storage\SMB')
-			->setText($l->t('SMB/CIFS'))
-			->addParameters([
-				new DefinitionParameter('host', $l->t('Host')),
-				new DefinitionParameter('share', $l->t('Share')),
-				(new DefinitionParameter('root', $l->t('Remote subfolder')))
-					->setFlag(DefinitionParameter::FLAG_OPTIONAL),
-				(new DefinitionParameter('domain', $l->t('Domain')))
-					->setFlag(DefinitionParameter::FLAG_OPTIONAL),
-				(new DefinitionParameter('show_hidden', $l->t('Show hidden files')))
-					->setType(DefinitionParameter::VALUE_BOOLEAN)
-					->setFlag(DefinitionParameter::FLAG_OPTIONAL),
-				(new DefinitionParameter('case_sensitive', $l->t('Case sensitive file system')))
-					->setType(DefinitionParameter::VALUE_BOOLEAN)
-					->setFlag(DefinitionParameter::FLAG_OPTIONAL)
-					->setDefaultValue(true)
-					->setTooltip($l->t('Disabling it will allow to use a case insensitive file system, but comes with a performance penalty')),
-				(new DefinitionParameter('check_acl', $l->t('Verify ACL access when listing files')))
-					->setType(DefinitionParameter::VALUE_BOOLEAN)
-					->setFlag(DefinitionParameter::FLAG_OPTIONAL)
-					->setTooltip($l->t("Check the ACL's of each file or folder inside a directory to filter out items where the account has no read permissions, comes with a performance penalty")),
-				(new DefinitionParameter('timeout', $l->t('Timeout')))
-					->setType(DefinitionParameter::VALUE_TEXT)
-					->setFlag(DefinitionParameter::FLAG_OPTIONAL)
-					->setFlag(DefinitionParameter::FLAG_HIDDEN),
-			])
-			->addAuthScheme(AuthMechanism::SCHEME_PASSWORD)
-			->addAuthScheme(AuthMechanism::SCHEME_SMB)
-			->setLegacyAuthMechanism($legacyAuth);
-	}
+    public function __construct(IL10N $l, Password $legacyAuth) {
+        $this
+            ->setIdentifier('smb')
+            ->addIdentifierAlias('\OC\Files\Storage\SMB')// legacy compat
+            ->setStorageClass('\OCA\Files_External\Lib\Storage\SMB')
+            ->setText($l->t('SMB/CIFS'))
+            ->addParameters([
+                new DefinitionParameter('host', $l->t('Host')),
+                new DefinitionParameter('share', $l->t('Share')),
+                (new DefinitionParameter('root', $l->t('Remote subfolder')))
+                    ->setFlag(DefinitionParameter::FLAG_OPTIONAL),
+                (new DefinitionParameter('domain', $l->t('Domain')))
+                    ->setFlag(DefinitionParameter::FLAG_OPTIONAL),
+                (new DefinitionParameter('show_hidden', $l->t('Show hidden files')))
+                    ->setType(DefinitionParameter::VALUE_BOOLEAN)
+                    ->setFlag(DefinitionParameter::FLAG_OPTIONAL),
+                (new DefinitionParameter('case_sensitive', $l->t('Case sensitive file system')))
+                    ->setType(DefinitionParameter::VALUE_BOOLEAN)
+                    ->setFlag(DefinitionParameter::FLAG_OPTIONAL)
+                    ->setDefaultValue(true)
+                    ->setTooltip($l->t('Disabling it will allow to use a case insensitive file system, but comes with a performance penalty')),
+                (new DefinitionParameter('check_acl', $l->t('Verify ACL access when listing files')))
+                    ->setType(DefinitionParameter::VALUE_BOOLEAN)
+                    ->setFlag(DefinitionParameter::FLAG_OPTIONAL)
+                    ->setTooltip($l->t("Check the ACL's of each file or folder inside a directory to filter out items where the account has no read permissions, comes with a performance penalty")),
+                (new DefinitionParameter('timeout', $l->t('Timeout')))
+                    ->setType(DefinitionParameter::VALUE_TEXT)
+                    ->setFlag(DefinitionParameter::FLAG_OPTIONAL)
+                    ->setFlag(DefinitionParameter::FLAG_HIDDEN),
+            ])
+            ->addAuthScheme(AuthMechanism::SCHEME_PASSWORD)
+            ->addAuthScheme(AuthMechanism::SCHEME_SMB)
+            ->setLegacyAuthMechanism($legacyAuth);
+    }
 
-	/**
-	 * @return void
-	 */
-	public function manipulateStorageConfig(StorageConfig &$storage, ?IUser $user = null) {
-		$auth = $storage->getAuthMechanism();
-		if ($auth->getScheme() === AuthMechanism::SCHEME_PASSWORD) {
-			if (!is_string($storage->getBackendOption('user')) || !is_string($storage->getBackendOption('password'))) {
-				throw new \InvalidArgumentException('user or password is not set');
-			}
+    /**
+     * @return void
+     */
+    public function manipulateStorageConfig(StorageConfig &$storage, ?IUser $user = null) {
+        $auth = $storage->getAuthMechanism();
+        if ($auth->getScheme() === AuthMechanism::SCHEME_PASSWORD) {
+            if (!is_string($storage->getBackendOption('user')) || !is_string($storage->getBackendOption('password'))) {
+                throw new \InvalidArgumentException('user or password is not set');
+            }
 
-			$smbAuth = new BasicAuth(
-				$storage->getBackendOption('user'),
-				$storage->getBackendOption('domain'),
-				$storage->getBackendOption('password')
-			);
-		} else {
-			switch ($auth->getIdentifier()) {
-				case 'smb::kerberos':
-					$smbAuth = new KerberosAuth();
-					break;
-				case 'smb::kerberosapache':
-					if (!$auth instanceof KerberosApacheAuthMechanism) {
-						throw new \InvalidArgumentException('invalid authentication backend');
-					}
-					$credentialsStore = $auth->getCredentialsStore();
-					$kerbAuth = new KerberosApacheAuth();
-					// check if a kerberos ticket is available, else fallback to session credentials
-					if ($kerbAuth->checkTicket()) {
-						$smbAuth = $kerbAuth;
-					} else {
-						try {
-							$credentials = $credentialsStore->getLoginCredentials();
-							$user = $credentials->getLoginName();
-							$pass = $credentials->getPassword();
-							preg_match('/(.*)@(.*)/', $user, $matches);
-							$realm = $storage->getBackendOption('default_realm');
-							if (empty($realm)) {
-								$realm = 'WORKGROUP';
-							}
-							if (count($matches) === 0) {
-								$username = $user;
-								$workgroup = $realm;
-							} else {
-								$username = $matches[1];
-								$workgroup = $matches[2];
-							}
-							$smbAuth = new BasicAuth(
-								$username,
-								$workgroup,
-								$pass
-							);
-						} catch (\Exception $e) {
-							throw new InsufficientDataForMeaningfulAnswerException('No session credentials saved');
-						}
-					}
+            $smbAuth = new BasicAuth(
+                $storage->getBackendOption('user'),
+                $storage->getBackendOption('domain'),
+                $storage->getBackendOption('password')
+            );
+        } else {
+            switch ($auth->getIdentifier()) {
+                case 'smb::kerberos':
+                    $smbAuth = new KerberosAuth();
+                    break;
+                case 'smb::kerberosapache':
+                    if (!$auth instanceof KerberosApacheAuthMechanism) {
+                        throw new \InvalidArgumentException('invalid authentication backend');
+                    }
+                    $credentialsStore = $auth->getCredentialsStore();
+                    $kerbAuth = new KerberosApacheAuth();
+                    // check if a kerberos ticket is available, else fallback to session credentials
+                    if ($kerbAuth->checkTicket()) {
+                        $smbAuth = $kerbAuth;
+                    } else {
+                        try {
+                            $credentials = $credentialsStore->getLoginCredentials();
+                            $user = $credentials->getLoginName();
+                            $pass = $credentials->getPassword();
+                            preg_match('/(.*)@(.*)/', $user, $matches);
+                            $realm = $storage->getBackendOption('default_realm');
+                            if (empty($realm)) {
+                                $realm = 'WORKGROUP';
+                            }
+                            if (count($matches) === 0) {
+                                $username = $user;
+                                $workgroup = $realm;
+                            } else {
+                                $username = $matches[1];
+                                $workgroup = $matches[2];
+                            }
+                            $smbAuth = new BasicAuth(
+                                $username,
+                                $workgroup,
+                                $pass
+                            );
+                        } catch (\Exception $e) {
+                            throw new InsufficientDataForMeaningfulAnswerException('No session credentials saved');
+                        }
+                    }
 
-					break;
-				default:
-					throw new \InvalidArgumentException('unknown authentication backend');
-			}
-		}
+                    break;
+                default:
+                    throw new \InvalidArgumentException('unknown authentication backend');
+            }
+        }
 
-		$storage->setBackendOption('auth', $smbAuth);
-	}
+        $storage->setBackendOption('auth', $smbAuth);
+    }
 }

apps/files_external/lib/Command/Backends.php

Indentation +76 added lines, -76 removed lines

@@ -16,88 +16,88 @@
 use Symfony\Component\Console\Output\OutputInterface;
 
 class Backends extends Base {
-	public function __construct(
-		private BackendService $backendService,
-	) {
-		parent::__construct();
-	}
+    public function __construct(
+        private BackendService $backendService,
+    ) {
+        parent::__construct();
+    }
 
-	protected function configure(): void {
-		$this
-			->setName('files_external:backends')
-			->setDescription('Show available authentication and storage backends')
-			->addArgument(
-				'type',
-				InputArgument::OPTIONAL,
-				'only show backends of a certain type. Possible values are "authentication" or "storage"'
-			)->addArgument(
-				'backend',
-				InputArgument::OPTIONAL,
-				'only show information of a specific backend'
-			);
-		parent::configure();
-	}
+    protected function configure(): void {
+        $this
+            ->setName('files_external:backends')
+            ->setDescription('Show available authentication and storage backends')
+            ->addArgument(
+                'type',
+                InputArgument::OPTIONAL,
+                'only show backends of a certain type. Possible values are "authentication" or "storage"'
+            )->addArgument(
+                'backend',
+                InputArgument::OPTIONAL,
+                'only show information of a specific backend'
+            );
+        parent::configure();
+    }
 
-	protected function execute(InputInterface $input, OutputInterface $output): int {
-		$authBackends = $this->backendService->getAuthMechanisms();
-		$storageBackends = $this->backendService->getBackends();
+    protected function execute(InputInterface $input, OutputInterface $output): int {
+        $authBackends = $this->backendService->getAuthMechanisms();
+        $storageBackends = $this->backendService->getBackends();
 
-		$data = [
-			'authentication' => array_map([$this, 'serializeAuthBackend'], $authBackends),
-			'storage' => array_map([$this, 'serializeAuthBackend'], $storageBackends)
-		];
+        $data = [
+            'authentication' => array_map([$this, 'serializeAuthBackend'], $authBackends),
+            'storage' => array_map([$this, 'serializeAuthBackend'], $storageBackends)
+        ];
 
-		$type = $input->getArgument('type');
-		$backend = $input->getArgument('backend');
-		if ($type) {
-			if (!isset($data[$type])) {
-				$output->writeln('<error>Invalid type "' . $type . '". Possible values are "authentication" or "storage"</error>');
-				return self::FAILURE;
-			}
-			$data = $data[$type];
+        $type = $input->getArgument('type');
+        $backend = $input->getArgument('backend');
+        if ($type) {
+            if (!isset($data[$type])) {
+                $output->writeln('<error>Invalid type "' . $type . '". Possible values are "authentication" or "storage"</error>');
+                return self::FAILURE;
+            }
+            $data = $data[$type];
 
-			if ($backend) {
-				if (!isset($data[$backend])) {
-					$output->writeln('<error>Unknown backend "' . $backend . '" of type  "' . $type . '"</error>');
-					return self::FAILURE;
-				}
-				$data = $data[$backend];
-			}
-		}
+            if ($backend) {
+                if (!isset($data[$backend])) {
+                    $output->writeln('<error>Unknown backend "' . $backend . '" of type  "' . $type . '"</error>');
+                    return self::FAILURE;
+                }
+                $data = $data[$backend];
+            }
+        }
 
-		$this->writeArrayInOutputFormat($input, $output, $data);
-		return self::SUCCESS;
-	}
+        $this->writeArrayInOutputFormat($input, $output, $data);
+        return self::SUCCESS;
+    }
 
-	private function serializeAuthBackend(\JsonSerializable $backend): array {
-		$data = $backend->jsonSerialize();
-		$result = [
-			'name' => $data['name'],
-			'identifier' => $data['identifier'],
-			'configuration' => $this->formatConfiguration($data['configuration'])
-		];
-		if ($backend instanceof Backend) {
-			$result['storage_class'] = $backend->getStorageClass();
-			$authBackends = $this->backendService->getAuthMechanismsByScheme(array_keys($backend->getAuthSchemes()));
-			$result['supported_authentication_backends'] = array_keys($authBackends);
-			$authConfig = array_map(function (AuthMechanism $auth) {
-				return $this->serializeAuthBackend($auth)['configuration'];
-			}, $authBackends);
-			$result['authentication_configuration'] = array_combine(array_keys($authBackends), $authConfig);
-		}
-		return $result;
-	}
+    private function serializeAuthBackend(\JsonSerializable $backend): array {
+        $data = $backend->jsonSerialize();
+        $result = [
+            'name' => $data['name'],
+            'identifier' => $data['identifier'],
+            'configuration' => $this->formatConfiguration($data['configuration'])
+        ];
+        if ($backend instanceof Backend) {
+            $result['storage_class'] = $backend->getStorageClass();
+            $authBackends = $this->backendService->getAuthMechanismsByScheme(array_keys($backend->getAuthSchemes()));
+            $result['supported_authentication_backends'] = array_keys($authBackends);
+            $authConfig = array_map(function (AuthMechanism $auth) {
+                return $this->serializeAuthBackend($auth)['configuration'];
+            }, $authBackends);
+            $result['authentication_configuration'] = array_combine(array_keys($authBackends), $authConfig);
+        }
+        return $result;
+    }
 
-	/**
-	 * @param DefinitionParameter[] $parameters
-	 * @return string[]
-	 */
-	private function formatConfiguration(array $parameters): array {
-		$configuration = array_filter($parameters, function (DefinitionParameter $parameter) {
-			return $parameter->isFlagSet(DefinitionParameter::FLAG_HIDDEN);
-		});
-		return array_map(function (DefinitionParameter $parameter) {
-			return $parameter->getTypeName();
-		}, $configuration);
-	}
+    /**
+     * @param DefinitionParameter[] $parameters
+     * @return string[]
+     */
+    private function formatConfiguration(array $parameters): array {
+        $configuration = array_filter($parameters, function (DefinitionParameter $parameter) {
+            return $parameter->isFlagSet(DefinitionParameter::FLAG_HIDDEN);
+        });
+        return array_map(function (DefinitionParameter $parameter) {
+            return $parameter->getTypeName();
+        }, $configuration);
+    }
 }

Spacing +5 added lines, -5 removed lines

@@ -51,14 +51,14 @@ 
 		$backend = $input->getArgument('backend');
 		if ($type) {
 			if (!isset($data[$type])) {
-				$output->writeln('<error>Invalid type "' . $type . '". Possible values are "authentication" or "storage"</error>');
+				$output->writeln('<error>Invalid type "'.$type.'". Possible values are "authentication" or "storage"</error>');
 				return self::FAILURE;
 			}
 			$data = $data[$type];
 
 			if ($backend) {
 				if (!isset($data[$backend])) {
-					$output->writeln('<error>Unknown backend "' . $backend . '" of type  "' . $type . '"</error>');
+					$output->writeln('<error>Unknown backend "'.$backend.'" of type  "'.$type.'"</error>');
 					return self::FAILURE;
 				}
 				$data = $data[$backend];
@@ -80,7 +80,7 @@ 
 			$result['storage_class'] = $backend->getStorageClass();
 			$authBackends = $this->backendService->getAuthMechanismsByScheme(array_keys($backend->getAuthSchemes()));
 			$result['supported_authentication_backends'] = array_keys($authBackends);
-			$authConfig = array_map(function (AuthMechanism $auth) {
+			$authConfig = array_map(function(AuthMechanism $auth) {
 				return $this->serializeAuthBackend($auth)['configuration'];
 			}, $authBackends);
 			$result['authentication_configuration'] = array_combine(array_keys($authBackends), $authConfig);
@@ -93,10 +93,10 @@ 
 	 * @return string[]
 	 */
 	private function formatConfiguration(array $parameters): array {
-		$configuration = array_filter($parameters, function (DefinitionParameter $parameter) {
+		$configuration = array_filter($parameters, function(DefinitionParameter $parameter) {
 			return $parameter->isFlagSet(DefinitionParameter::FLAG_HIDDEN);
 		});
-		return array_map(function (DefinitionParameter $parameter) {
+		return array_map(function(DefinitionParameter $parameter) {
 			return $parameter->getTypeName();
 		}, $configuration);
 	}