nextcloud / server

apps/files_external/lib/AppInfo/Application.php

Indentation +99 added lines, -99 removed lines

@@ -59,103 +59,103 @@
  * @package OCA\Files_External\AppInfo
  */
 class Application extends App implements IBackendProvider, IAuthMechanismProvider, IBootstrap {
-	public const APP_ID = 'files_external';
-
-	/**
-	 * Application constructor.
-	 *
-	 * @throws QueryException
-	 */
-	public function __construct(array $urlParams = []) {
-		parent::__construct(self::APP_ID, $urlParams);
-	}
-
-	public function register(IRegistrationContext $context): void {
-		$context->registerEventListener(UserDeletedEvent::class, UserDeletedListener::class);
-		$context->registerEventListener(GroupDeletedEvent::class, GroupDeletedListener::class);
-		$context->registerEventListener(LoadAdditionalScriptsEvent::class, LoadAdditionalListener::class);
-		$context->registerConfigLexicon(ConfigLexicon::class);
-	}
-
-	public function boot(IBootContext $context): void {
-		$context->injectFn(function (IMountProviderCollection $mountProviderCollection, ConfigAdapter $configAdapter): void {
-			$mountProviderCollection->registerProvider($configAdapter);
-		});
-		$context->injectFn(function (BackendService $backendService, UserPlaceholderHandler $userConfigHandler): void {
-			$backendService->registerBackendProvider($this);
-			$backendService->registerAuthMechanismProvider($this);
-			$backendService->registerConfigHandler('user', function () use ($userConfigHandler) {
-				return $userConfigHandler;
-			});
-		});
-
-		// force-load auth mechanisms since some will register hooks
-		// TODO: obsolete these and use the TokenProvider to get the user's password from the session
-		$this->getAuthMechanisms();
-	}
-
-	/**
-	 * @{inheritdoc}
-	 */
-	public function getBackends() {
-		$container = $this->getContainer();
-
-		$backends = [
-			$container->get(Local::class),
-			$container->get(FTP::class),
-			$container->get(DAV::class),
-			$container->get(OwnCloud::class),
-			$container->get(SFTP::class),
-			$container->get(AmazonS3::class),
-			$container->get(Swift::class),
-			$container->get(SFTP_Key::class),
-			$container->get(SMB::class),
-			$container->get(SMB_OC::class),
-		];
-
-		return $backends;
-	}
-
-	/**
-	 * @{inheritdoc}
-	 */
-	public function getAuthMechanisms() {
-		$container = $this->getContainer();
-
-		return [
-			// AuthMechanism::SCHEME_NULL mechanism
-			$container->get(NullMechanism::class),
-
-			// AuthMechanism::SCHEME_BUILTIN mechanism
-			$container->get(Builtin::class),
-
-			// AuthMechanism::SCHEME_PASSWORD mechanisms
-			$container->get(Password::class),
-			$container->get(SessionCredentials::class),
-			$container->get(LoginCredentials::class),
-			$container->get(UserProvided::class),
-			$container->get(GlobalAuth::class),
-			$container->get(UserGlobalAuth::class),
-
-			// AuthMechanism::SCHEME_OAUTH1 mechanisms
-			$container->get(OAuth1::class),
-
-			// AuthMechanism::SCHEME_OAUTH2 mechanisms
-			$container->get(OAuth2::class),
-
-			// AuthMechanism::SCHEME_PUBLICKEY mechanisms
-			$container->get(RSA::class),
-			$container->get(RSAPrivateKey::class),
-
-			// AuthMechanism::SCHEME_OPENSTACK mechanisms
-			$container->get(OpenStackV2::class),
-			$container->get(OpenStackV3::class),
-			$container->get(Rackspace::class),
-
-			// Specialized mechanisms
-			$container->get(AccessKey::class),
-			$container->get(KerberosAuth::class),
-			$container->get(KerberosApacheAuth::class),
-		];
-	}
+    public const APP_ID = 'files_external';
+
+    /**
+     * Application constructor.
+     *
+     * @throws QueryException
+     */
+    public function __construct(array $urlParams = []) {
+        parent::__construct(self::APP_ID, $urlParams);
+    }
+
+    public function register(IRegistrationContext $context): void {
+        $context->registerEventListener(UserDeletedEvent::class, UserDeletedListener::class);
+        $context->registerEventListener(GroupDeletedEvent::class, GroupDeletedListener::class);
+        $context->registerEventListener(LoadAdditionalScriptsEvent::class, LoadAdditionalListener::class);
+        $context->registerConfigLexicon(ConfigLexicon::class);
+    }
+
+    public function boot(IBootContext $context): void {
+        $context->injectFn(function (IMountProviderCollection $mountProviderCollection, ConfigAdapter $configAdapter): void {
+            $mountProviderCollection->registerProvider($configAdapter);
+        });
+        $context->injectFn(function (BackendService $backendService, UserPlaceholderHandler $userConfigHandler): void {
+            $backendService->registerBackendProvider($this);
+            $backendService->registerAuthMechanismProvider($this);
+            $backendService->registerConfigHandler('user', function () use ($userConfigHandler) {
+                return $userConfigHandler;
+            });
+        });
+
+        // force-load auth mechanisms since some will register hooks
+        // TODO: obsolete these and use the TokenProvider to get the user's password from the session
+        $this->getAuthMechanisms();
+    }
+
+    /**
+     * @{inheritdoc}
+     */
+    public function getBackends() {
+        $container = $this->getContainer();
+
+        $backends = [
+            $container->get(Local::class),
+            $container->get(FTP::class),
+            $container->get(DAV::class),
+            $container->get(OwnCloud::class),
+            $container->get(SFTP::class),
+            $container->get(AmazonS3::class),
+            $container->get(Swift::class),
+            $container->get(SFTP_Key::class),
+            $container->get(SMB::class),
+            $container->get(SMB_OC::class),
+        ];
+
+        return $backends;
+    }
+
+    /**
+     * @{inheritdoc}
+     */
+    public function getAuthMechanisms() {
+        $container = $this->getContainer();
+
+        return [
+            // AuthMechanism::SCHEME_NULL mechanism
+            $container->get(NullMechanism::class),
+
+            // AuthMechanism::SCHEME_BUILTIN mechanism
+            $container->get(Builtin::class),
+
+            // AuthMechanism::SCHEME_PASSWORD mechanisms
+            $container->get(Password::class),
+            $container->get(SessionCredentials::class),
+            $container->get(LoginCredentials::class),
+            $container->get(UserProvided::class),
+            $container->get(GlobalAuth::class),
+            $container->get(UserGlobalAuth::class),
+
+            // AuthMechanism::SCHEME_OAUTH1 mechanisms
+            $container->get(OAuth1::class),
+
+            // AuthMechanism::SCHEME_OAUTH2 mechanisms
+            $container->get(OAuth2::class),
+
+            // AuthMechanism::SCHEME_PUBLICKEY mechanisms
+            $container->get(RSA::class),
+            $container->get(RSAPrivateKey::class),
+
+            // AuthMechanism::SCHEME_OPENSTACK mechanisms
+            $container->get(OpenStackV2::class),
+            $container->get(OpenStackV3::class),
+            $container->get(Rackspace::class),
+
+            // Specialized mechanisms
+            $container->get(AccessKey::class),
+            $container->get(KerberosAuth::class),
+            $container->get(KerberosApacheAuth::class),
+        ];
+    }
 }

apps/files_external/lib/Service/BackendService.php

Indentation +314 added lines, -314 removed lines

@@ -22,318 +22,318 @@
  */
 class BackendService {
 
-	/** Visibility constants for VisibilityTrait */
-	public const VISIBILITY_NONE = 0;
-	public const VISIBILITY_PERSONAL = 1;
-	public const VISIBILITY_ADMIN = 2;
-	//const VISIBILITY_ALIENS = 4;
-
-	public const VISIBILITY_DEFAULT = 3; // PERSONAL | ADMIN
-
-	/** Priority constants for PriorityTrait */
-	public const PRIORITY_DEFAULT = 100;
-
-	/** @var bool */
-	private $userMountingAllowed = true;
-
-	/** @var string[] */
-	private $userMountingBackends = [];
-
-	/** @var Backend[] */
-	private $backends = [];
-
-	/** @var IBackendProvider[] */
-	private $backendProviders = [];
-
-	/** @var AuthMechanism[] */
-	private $authMechanisms = [];
-
-	/** @var IAuthMechanismProvider[] */
-	private $authMechanismProviders = [];
-
-	/** @var callable[] */
-	private $configHandlerLoaders = [];
-
-	private $configHandlers = [];
-
-	public function __construct(
-		protected IAppConfig $appConfig,
-	) {
-		// Load config values
-		$this->userMountingAllowed = $appConfig->getValueBool('files_external', ConfigLexicon::ALLOW_USER_MOUNTING);
-		$this->userMountingBackends = explode(',', $appConfig->getValueString('files_external', ConfigLexicon::USER_MOUNTING_BACKENDS));
-
-		// if no backend is in the list an empty string is in the array and user mounting is disabled
-		if ($this->userMountingBackends === ['']) {
-			$this->userMountingAllowed = false;
-		}
-	}
-
-	/**
-	 * Register a backend provider
-	 *
-	 * @since 9.1.0
-	 * @param IBackendProvider $provider
-	 */
-	public function registerBackendProvider(IBackendProvider $provider) {
-		$this->backendProviders[] = $provider;
-	}
-
-	private function callForRegistrations() {
-		static $eventSent = false;
-		if (!$eventSent) {
-			Server::get(IEventDispatcher::class)->dispatch(
-				'OCA\\Files_External::loadAdditionalBackends',
-				new GenericEvent()
-			);
-			$eventSent = true;
-		}
-	}
-
-	private function loadBackendProviders() {
-		$this->callForRegistrations();
-		foreach ($this->backendProviders as $provider) {
-			$this->registerBackends($provider->getBackends());
-		}
-		$this->backendProviders = [];
-	}
-
-	/**
-	 * Register an auth mechanism provider
-	 *
-	 * @since 9.1.0
-	 * @param IAuthMechanismProvider $provider
-	 */
-	public function registerAuthMechanismProvider(IAuthMechanismProvider $provider) {
-		$this->authMechanismProviders[] = $provider;
-	}
-
-	private function loadAuthMechanismProviders() {
-		$this->callForRegistrations();
-		foreach ($this->authMechanismProviders as $provider) {
-			$this->registerAuthMechanisms($provider->getAuthMechanisms());
-		}
-		$this->authMechanismProviders = [];
-	}
-
-	/**
-	 * Register a backend
-	 *
-	 * @deprecated 9.1.0 use registerBackendProvider()
-	 * @param Backend $backend
-	 */
-	public function registerBackend(Backend $backend) {
-		if (!$this->isAllowedUserBackend($backend)) {
-			$backend->removeVisibility(BackendService::VISIBILITY_PERSONAL);
-		}
-		foreach ($backend->getIdentifierAliases() as $alias) {
-			$this->backends[$alias] = $backend;
-		}
-	}
-
-	/**
-	 * @deprecated 9.1.0 use registerBackendProvider()
-	 * @param Backend[] $backends
-	 */
-	public function registerBackends(array $backends) {
-		foreach ($backends as $backend) {
-			$this->registerBackend($backend);
-		}
-	}
-	/**
-	 * Register an authentication mechanism
-	 *
-	 * @deprecated 9.1.0 use registerAuthMechanismProvider()
-	 * @param AuthMechanism $authMech
-	 */
-	public function registerAuthMechanism(AuthMechanism $authMech) {
-		if (!$this->isAllowedAuthMechanism($authMech)) {
-			$authMech->removeVisibility(BackendService::VISIBILITY_PERSONAL);
-		}
-		foreach ($authMech->getIdentifierAliases() as $alias) {
-			$this->authMechanisms[$alias] = $authMech;
-		}
-	}
-
-	/**
-	 * @deprecated 9.1.0 use registerAuthMechanismProvider()
-	 * @param AuthMechanism[] $mechanisms
-	 */
-	public function registerAuthMechanisms(array $mechanisms) {
-		foreach ($mechanisms as $mechanism) {
-			$this->registerAuthMechanism($mechanism);
-		}
-	}
-
-	/**
-	 * Get all backends
-	 *
-	 * @return Backend[]
-	 */
-	public function getBackends() {
-		$this->loadBackendProviders();
-		// only return real identifiers, no aliases
-		$backends = [];
-		foreach ($this->backends as $backend) {
-			$backends[$backend->getIdentifier()] = $backend;
-		}
-		return $backends;
-	}
-
-	/**
-	 * Get all available backends
-	 *
-	 * @return Backend[]
-	 */
-	public function getAvailableBackends() {
-		return array_filter($this->getBackends(), function ($backend) {
-			return !$backend->checkDependencies();
-		});
-	}
-
-	/**
-	 * @param string $identifier
-	 * @return Backend|null
-	 */
-	public function getBackend($identifier) {
-		$this->loadBackendProviders();
-		if (isset($this->backends[$identifier])) {
-			return $this->backends[$identifier];
-		}
-		return null;
-	}
-
-	/**
-	 * Get all authentication mechanisms
-	 *
-	 * @return AuthMechanism[]
-	 */
-	public function getAuthMechanisms() {
-		$this->loadAuthMechanismProviders();
-		// only return real identifiers, no aliases
-		$mechanisms = [];
-		foreach ($this->authMechanisms as $mechanism) {
-			$mechanisms[$mechanism->getIdentifier()] = $mechanism;
-		}
-		return $mechanisms;
-	}
-
-	/**
-	 * Get all authentication mechanisms for schemes
-	 *
-	 * @param string[] $schemes
-	 * @return AuthMechanism[]
-	 */
-	public function getAuthMechanismsByScheme(array $schemes) {
-		return array_filter($this->getAuthMechanisms(), function ($authMech) use ($schemes) {
-			return in_array($authMech->getScheme(), $schemes, true);
-		});
-	}
-
-	/**
-	 * @param string $identifier
-	 * @return AuthMechanism|null
-	 */
-	public function getAuthMechanism($identifier) {
-		$this->loadAuthMechanismProviders();
-		if (isset($this->authMechanisms[$identifier])) {
-			return $this->authMechanisms[$identifier];
-		}
-		return null;
-	}
-
-	/**
-	 * @return bool
-	 */
-	public function isUserMountingAllowed() {
-		return $this->userMountingAllowed;
-	}
-
-	/**
-	 * Check a backend if a user is allowed to mount it
-	 *
-	 * @param Backend $backend
-	 * @return bool
-	 */
-	protected function isAllowedUserBackend(Backend $backend) {
-		if ($this->userMountingAllowed &&
-			array_intersect($backend->getIdentifierAliases(), $this->userMountingBackends)
-		) {
-			return true;
-		}
-		return false;
-	}
-
-	/**
-	 * Check an authentication mechanism if a user is allowed to use it
-	 *
-	 * @param AuthMechanism $authMechanism
-	 * @return bool
-	 */
-	protected function isAllowedAuthMechanism(AuthMechanism $authMechanism) {
-		return true; // not implemented
-	}
-
-	/**
-	 * registers a configuration handler
-	 *
-	 * The function of the provided $placeholder is mostly to act a sorting
-	 * criteria, so longer placeholders are replaced first. This avoids
-	 * "$user" overwriting parts of "$userMail" and "$userLang", for example.
-	 * The provided value should not contain the $ prefix, only a-z0-9 are
-	 * allowed. Upper case letters are lower cased, the replacement is case-
-	 * insensitive.
-	 *
-	 * The configHandlerLoader should just instantiate the handler on demand.
-	 * For now all handlers are instantiated when a mount is loaded, independent
-	 * of whether the placeholder is present or not. This may change in future.
-	 *
-	 * @since 16.0.0
-	 */
-	public function registerConfigHandler(string $placeholder, callable $configHandlerLoader) {
-		$placeholder = trim(strtolower($placeholder));
-		if (!(bool)\preg_match('/^[a-z0-9]*$/', $placeholder)) {
-			throw new \RuntimeException(sprintf(
-				'Invalid placeholder %s, only [a-z0-9] are allowed', $placeholder
-			));
-		}
-		if ($placeholder === '') {
-			throw new \RuntimeException('Invalid empty placeholder');
-		}
-		if (isset($this->configHandlerLoaders[$placeholder]) || isset($this->configHandlers[$placeholder])) {
-			throw new \RuntimeException(sprintf('A handler is already registered for %s', $placeholder));
-		}
-		$this->configHandlerLoaders[$placeholder] = $configHandlerLoader;
-	}
-
-	protected function loadConfigHandlers():void {
-		$this->callForRegistrations();
-		$newLoaded = false;
-		foreach ($this->configHandlerLoaders as $placeholder => $loader) {
-			$handler = $loader();
-			if (!$handler instanceof IConfigHandler) {
-				throw new \RuntimeException(sprintf(
-					'Handler for %s is not an instance of IConfigHandler', $placeholder
-				));
-			}
-			$this->configHandlers[$placeholder] = $handler;
-			$newLoaded = true;
-		}
-		$this->configHandlerLoaders = [];
-		if ($newLoaded) {
-			// ensure those with longest placeholders come first,
-			// to avoid substring matches
-			uksort($this->configHandlers, function ($phA, $phB) {
-				return strlen($phB) <=> strlen($phA);
-			});
-		}
-	}
-
-	/**
-	 * @since 16.0.0
-	 */
-	public function getConfigHandlers() {
-		$this->loadConfigHandlers();
-		return $this->configHandlers;
-	}
+    /** Visibility constants for VisibilityTrait */
+    public const VISIBILITY_NONE = 0;
+    public const VISIBILITY_PERSONAL = 1;
+    public const VISIBILITY_ADMIN = 2;
+    //const VISIBILITY_ALIENS = 4;
+
+    public const VISIBILITY_DEFAULT = 3; // PERSONAL | ADMIN
+
+    /** Priority constants for PriorityTrait */
+    public const PRIORITY_DEFAULT = 100;
+
+    /** @var bool */
+    private $userMountingAllowed = true;
+
+    /** @var string[] */
+    private $userMountingBackends = [];
+
+    /** @var Backend[] */
+    private $backends = [];
+
+    /** @var IBackendProvider[] */
+    private $backendProviders = [];
+
+    /** @var AuthMechanism[] */
+    private $authMechanisms = [];
+
+    /** @var IAuthMechanismProvider[] */
+    private $authMechanismProviders = [];
+
+    /** @var callable[] */
+    private $configHandlerLoaders = [];
+
+    private $configHandlers = [];
+
+    public function __construct(
+        protected IAppConfig $appConfig,
+    ) {
+        // Load config values
+        $this->userMountingAllowed = $appConfig->getValueBool('files_external', ConfigLexicon::ALLOW_USER_MOUNTING);
+        $this->userMountingBackends = explode(',', $appConfig->getValueString('files_external', ConfigLexicon::USER_MOUNTING_BACKENDS));
+
+        // if no backend is in the list an empty string is in the array and user mounting is disabled
+        if ($this->userMountingBackends === ['']) {
+            $this->userMountingAllowed = false;
+        }
+    }
+
+    /**
+     * Register a backend provider
+     *
+     * @since 9.1.0
+     * @param IBackendProvider $provider
+     */
+    public function registerBackendProvider(IBackendProvider $provider) {
+        $this->backendProviders[] = $provider;
+    }
+
+    private function callForRegistrations() {
+        static $eventSent = false;
+        if (!$eventSent) {
+            Server::get(IEventDispatcher::class)->dispatch(
+                'OCA\\Files_External::loadAdditionalBackends',
+                new GenericEvent()
+            );
+            $eventSent = true;
+        }
+    }
+
+    private function loadBackendProviders() {
+        $this->callForRegistrations();
+        foreach ($this->backendProviders as $provider) {
+            $this->registerBackends($provider->getBackends());
+        }
+        $this->backendProviders = [];
+    }
+
+    /**
+     * Register an auth mechanism provider
+     *
+     * @since 9.1.0
+     * @param IAuthMechanismProvider $provider
+     */
+    public function registerAuthMechanismProvider(IAuthMechanismProvider $provider) {
+        $this->authMechanismProviders[] = $provider;
+    }
+
+    private function loadAuthMechanismProviders() {
+        $this->callForRegistrations();
+        foreach ($this->authMechanismProviders as $provider) {
+            $this->registerAuthMechanisms($provider->getAuthMechanisms());
+        }
+        $this->authMechanismProviders = [];
+    }
+
+    /**
+     * Register a backend
+     *
+     * @deprecated 9.1.0 use registerBackendProvider()
+     * @param Backend $backend
+     */
+    public function registerBackend(Backend $backend) {
+        if (!$this->isAllowedUserBackend($backend)) {
+            $backend->removeVisibility(BackendService::VISIBILITY_PERSONAL);
+        }
+        foreach ($backend->getIdentifierAliases() as $alias) {
+            $this->backends[$alias] = $backend;
+        }
+    }
+
+    /**
+     * @deprecated 9.1.0 use registerBackendProvider()
+     * @param Backend[] $backends
+     */
+    public function registerBackends(array $backends) {
+        foreach ($backends as $backend) {
+            $this->registerBackend($backend);
+        }
+    }
+    /**
+     * Register an authentication mechanism
+     *
+     * @deprecated 9.1.0 use registerAuthMechanismProvider()
+     * @param AuthMechanism $authMech
+     */
+    public function registerAuthMechanism(AuthMechanism $authMech) {
+        if (!$this->isAllowedAuthMechanism($authMech)) {
+            $authMech->removeVisibility(BackendService::VISIBILITY_PERSONAL);
+        }
+        foreach ($authMech->getIdentifierAliases() as $alias) {
+            $this->authMechanisms[$alias] = $authMech;
+        }
+    }
+
+    /**
+     * @deprecated 9.1.0 use registerAuthMechanismProvider()
+     * @param AuthMechanism[] $mechanisms
+     */
+    public function registerAuthMechanisms(array $mechanisms) {
+        foreach ($mechanisms as $mechanism) {
+            $this->registerAuthMechanism($mechanism);
+        }
+    }
+
+    /**
+     * Get all backends
+     *
+     * @return Backend[]
+     */
+    public function getBackends() {
+        $this->loadBackendProviders();
+        // only return real identifiers, no aliases
+        $backends = [];
+        foreach ($this->backends as $backend) {
+            $backends[$backend->getIdentifier()] = $backend;
+        }
+        return $backends;
+    }
+
+    /**
+     * Get all available backends
+     *
+     * @return Backend[]
+     */
+    public function getAvailableBackends() {
+        return array_filter($this->getBackends(), function ($backend) {
+            return !$backend->checkDependencies();
+        });
+    }
+
+    /**
+     * @param string $identifier
+     * @return Backend|null
+     */
+    public function getBackend($identifier) {
+        $this->loadBackendProviders();
+        if (isset($this->backends[$identifier])) {
+            return $this->backends[$identifier];
+        }
+        return null;
+    }
+
+    /**
+     * Get all authentication mechanisms
+     *
+     * @return AuthMechanism[]
+     */
+    public function getAuthMechanisms() {
+        $this->loadAuthMechanismProviders();
+        // only return real identifiers, no aliases
+        $mechanisms = [];
+        foreach ($this->authMechanisms as $mechanism) {
+            $mechanisms[$mechanism->getIdentifier()] = $mechanism;
+        }
+        return $mechanisms;
+    }
+
+    /**
+     * Get all authentication mechanisms for schemes
+     *
+     * @param string[] $schemes
+     * @return AuthMechanism[]
+     */
+    public function getAuthMechanismsByScheme(array $schemes) {
+        return array_filter($this->getAuthMechanisms(), function ($authMech) use ($schemes) {
+            return in_array($authMech->getScheme(), $schemes, true);
+        });
+    }
+
+    /**
+     * @param string $identifier
+     * @return AuthMechanism|null
+     */
+    public function getAuthMechanism($identifier) {
+        $this->loadAuthMechanismProviders();
+        if (isset($this->authMechanisms[$identifier])) {
+            return $this->authMechanisms[$identifier];
+        }
+        return null;
+    }
+
+    /**
+     * @return bool
+     */
+    public function isUserMountingAllowed() {
+        return $this->userMountingAllowed;
+    }
+
+    /**
+     * Check a backend if a user is allowed to mount it
+     *
+     * @param Backend $backend
+     * @return bool
+     */
+    protected function isAllowedUserBackend(Backend $backend) {
+        if ($this->userMountingAllowed &&
+            array_intersect($backend->getIdentifierAliases(), $this->userMountingBackends)
+        ) {
+            return true;
+        }
+        return false;
+    }
+
+    /**
+     * Check an authentication mechanism if a user is allowed to use it
+     *
+     * @param AuthMechanism $authMechanism
+     * @return bool
+     */
+    protected function isAllowedAuthMechanism(AuthMechanism $authMechanism) {
+        return true; // not implemented
+    }
+
+    /**
+     * registers a configuration handler
+     *
+     * The function of the provided $placeholder is mostly to act a sorting
+     * criteria, so longer placeholders are replaced first. This avoids
+     * "$user" overwriting parts of "$userMail" and "$userLang", for example.
+     * The provided value should not contain the $ prefix, only a-z0-9 are
+     * allowed. Upper case letters are lower cased, the replacement is case-
+     * insensitive.
+     *
+     * The configHandlerLoader should just instantiate the handler on demand.
+     * For now all handlers are instantiated when a mount is loaded, independent
+     * of whether the placeholder is present or not. This may change in future.
+     *
+     * @since 16.0.0
+     */
+    public function registerConfigHandler(string $placeholder, callable $configHandlerLoader) {
+        $placeholder = trim(strtolower($placeholder));
+        if (!(bool)\preg_match('/^[a-z0-9]*$/', $placeholder)) {
+            throw new \RuntimeException(sprintf(
+                'Invalid placeholder %s, only [a-z0-9] are allowed', $placeholder
+            ));
+        }
+        if ($placeholder === '') {
+            throw new \RuntimeException('Invalid empty placeholder');
+        }
+        if (isset($this->configHandlerLoaders[$placeholder]) || isset($this->configHandlers[$placeholder])) {
+            throw new \RuntimeException(sprintf('A handler is already registered for %s', $placeholder));
+        }
+        $this->configHandlerLoaders[$placeholder] = $configHandlerLoader;
+    }
+
+    protected function loadConfigHandlers():void {
+        $this->callForRegistrations();
+        $newLoaded = false;
+        foreach ($this->configHandlerLoaders as $placeholder => $loader) {
+            $handler = $loader();
+            if (!$handler instanceof IConfigHandler) {
+                throw new \RuntimeException(sprintf(
+                    'Handler for %s is not an instance of IConfigHandler', $placeholder
+                ));
+            }
+            $this->configHandlers[$placeholder] = $handler;
+            $newLoaded = true;
+        }
+        $this->configHandlerLoaders = [];
+        if ($newLoaded) {
+            // ensure those with longest placeholders come first,
+            // to avoid substring matches
+            uksort($this->configHandlers, function ($phA, $phB) {
+                return strlen($phB) <=> strlen($phA);
+            });
+        }
+    }
+
+    /**
+     * @since 16.0.0
+     */
+    public function getConfigHandlers() {
+        $this->loadConfigHandlers();
+        return $this->configHandlers;
+    }
 }

apps/files_external/lib/ConfigLexicon.php

Indentation +14 added lines, -14 removed lines

@@ -21,21 +21,21 @@
  * {@see IConfigLexicon}
  */
 class ConfigLexicon implements IConfigLexicon {
-	public const ALLOW_USER_MOUNTING = 'allow_user_mounting';
-	public const USER_MOUNTING_BACKENDS = 'user_mounting_backends';
+    public const ALLOW_USER_MOUNTING = 'allow_user_mounting';
+    public const USER_MOUNTING_BACKENDS = 'user_mounting_backends';
 
-	public function getStrictness(): ConfigLexiconStrictness {
-		return ConfigLexiconStrictness::NOTICE;
-	}
+    public function getStrictness(): ConfigLexiconStrictness {
+        return ConfigLexiconStrictness::NOTICE;
+    }
 
-	public function getAppConfigs(): array {
-		return [
-			new ConfigLexiconEntry(self::ALLOW_USER_MOUNTING, ValueType::BOOL, false, 'allow users to mount their own external filesystems', true),
-			new ConfigLexiconEntry(self::USER_MOUNTING_BACKENDS, ValueType::STRING, '', 'list of mounting backends available for users', true),
-		];
-	}
+    public function getAppConfigs(): array {
+        return [
+            new ConfigLexiconEntry(self::ALLOW_USER_MOUNTING, ValueType::BOOL, false, 'allow users to mount their own external filesystems', true),
+            new ConfigLexiconEntry(self::USER_MOUNTING_BACKENDS, ValueType::STRING, '', 'list of mounting backends available for users', true),
+        ];
+    }
 
-	public function getUserConfigs(): array {
-		return [];
-	}
+    public function getUserConfigs(): array {
+        return [];
+    }
 }

apps/files_external/lib/Listener/LoadAdditionalListener.php

Indentation +16 added lines, -16 removed lines

@@ -22,20 +22,20 @@
  */
 class LoadAdditionalListener implements IEventListener {
 
-	public function __construct(
-		private readonly IAppConfig $appConfig,
-		private IInitialState $initialState,
-	) {
-	}
-
-	public function handle(Event $event): void {
-		if (!($event instanceof LoadAdditionalScriptsEvent)) {
-			return;
-		}
-
-		$allowUserMounting = $this->appConfig->getValueBool('files_external', ConfigLexicon::ALLOW_USER_MOUNTING);
-		$this->initialState->provideInitialState('allowUserMounting', $allowUserMounting);
-
-		Util::addInitScript(Application::APP_ID, 'init');
-	}
+    public function __construct(
+        private readonly IAppConfig $appConfig,
+        private IInitialState $initialState,
+    ) {
+    }
+
+    public function handle(Event $event): void {
+        if (!($event instanceof LoadAdditionalScriptsEvent)) {
+            return;
+        }
+
+        $allowUserMounting = $this->appConfig->getValueBool('files_external', ConfigLexicon::ALLOW_USER_MOUNTING);
+        $this->initialState->provideInitialState('allowUserMounting', $allowUserMounting);
+
+        Util::addInitScript(Application::APP_ID, 'init');
+    }
 }

apps/files_external/tests/Service/BackendServiceTest.php

Indentation +235 added lines, -235 removed lines

@@ -16,239 +16,239 @@
 
 class BackendServiceTest extends \Test\TestCase {
 
-	/** @var IAppConfig|\PHPUnit\Framework\MockObject\MockObject */
-	protected $appConfig;
-
-	protected function setUp(): void {
-		$this->appConfig = $this->createMock(IAppConfig::class);
-	}
-
-	/**
-	 * @param string $class
-	 *
-	 * @return \OCA\Files_External\Lib\Backend\Backend|\PHPUnit\Framework\MockObject\MockObject
-	 */
-	protected function getBackendMock($class) {
-		$backend = $this->getMockBuilder(Backend::class)
-			->disableOriginalConstructor()
-			->getMock();
-		$backend->method('getIdentifier')->willReturn('identifier:' . $class);
-		$backend->method('getIdentifierAliases')->willReturn(['identifier:' . $class]);
-		return $backend;
-	}
-
-	/**
-	 * @param string $class
-	 *
-	 * @return AuthMechanism|\PHPUnit\Framework\MockObject\MockObject
-	 */
-	protected function getAuthMechanismMock($class) {
-		$backend = $this->getMockBuilder(AuthMechanism::class)
-			->disableOriginalConstructor()
-			->getMock();
-		$backend->method('getIdentifier')->willReturn('identifier:' . $class);
-		$backend->method('getIdentifierAliases')->willReturn(['identifier:' . $class]);
-		return $backend;
-	}
-
-	public function testRegisterBackend(): void {
-		$service = new BackendService($this->appConfig);
-
-		$backend = $this->getBackendMock('\Foo\Bar');
-
-		/** @var \OCA\Files_External\Lib\Backend\Backend|\PHPUnit\Framework\MockObject\MockObject $backendAlias */
-		$backendAlias = $this->getMockBuilder(Backend::class)
-			->disableOriginalConstructor()
-			->getMock();
-		$backendAlias->method('getIdentifierAliases')
-			->willReturn(['identifier_real', 'identifier_alias']);
-		$backendAlias->method('getIdentifier')
-			->willReturn('identifier_real');
-
-		$service->registerBackend($backend);
-		$service->registerBackend($backendAlias);
-
-		$this->assertEquals($backend, $service->getBackend('identifier:\Foo\Bar'));
-		$this->assertEquals($backendAlias, $service->getBackend('identifier_real'));
-		$this->assertEquals($backendAlias, $service->getBackend('identifier_alias'));
-
-		$backends = $service->getBackends();
-		$this->assertCount(2, $backends);
-		$this->assertArrayHasKey('identifier:\Foo\Bar', $backends);
-		$this->assertArrayHasKey('identifier_real', $backends);
-		$this->assertArrayNotHasKey('identifier_alias', $backends);
-	}
-
-	public function testBackendProvider(): void {
-		$service = new BackendService($this->appConfig);
-
-		$backend1 = $this->getBackendMock('\Foo\Bar');
-		$backend2 = $this->getBackendMock('\Bar\Foo');
-
-		/** @var IBackendProvider|\PHPUnit\Framework\MockObject\MockObject $providerMock */
-		$providerMock = $this->createMock(IBackendProvider::class);
-		$providerMock->expects($this->once())
-			->method('getBackends')
-			->willReturn([$backend1, $backend2]);
-		$service->registerBackendProvider($providerMock);
-
-		$this->assertEquals($backend1, $service->getBackend('identifier:\Foo\Bar'));
-		$this->assertEquals($backend2, $service->getBackend('identifier:\Bar\Foo'));
-
-		$this->assertCount(2, $service->getBackends());
-	}
-
-	public function testAuthMechanismProvider(): void {
-		$service = new BackendService($this->appConfig);
-
-		$backend1 = $this->getAuthMechanismMock('\Foo\Bar');
-		$backend2 = $this->getAuthMechanismMock('\Bar\Foo');
-
-		/** @var IAuthMechanismProvider|\PHPUnit\Framework\MockObject\MockObject $providerMock */
-		$providerMock = $this->createMock(IAuthMechanismProvider::class);
-		$providerMock->expects($this->once())
-			->method('getAuthMechanisms')
-			->willReturn([$backend1, $backend2]);
-		$service->registerAuthMechanismProvider($providerMock);
-
-		$this->assertEquals($backend1, $service->getAuthMechanism('identifier:\Foo\Bar'));
-		$this->assertEquals($backend2, $service->getAuthMechanism('identifier:\Bar\Foo'));
-
-		$this->assertCount(2, $service->getAuthMechanisms());
-	}
-
-	public function testMultipleBackendProviders(): void {
-		$service = new BackendService($this->appConfig);
-
-		$backend1a = $this->getBackendMock('\Foo\Bar');
-		$backend1b = $this->getBackendMock('\Bar\Foo');
-
-		$backend2 = $this->getBackendMock('\Dead\Beef');
-
-		/** @var IBackendProvider|\PHPUnit\Framework\MockObject\MockObject $provider1Mock */
-		$provider1Mock = $this->createMock(IBackendProvider::class);
-		$provider1Mock->expects($this->once())
-			->method('getBackends')
-			->willReturn([$backend1a, $backend1b]);
-		$service->registerBackendProvider($provider1Mock);
-		/** @var IBackendProvider|\PHPUnit\Framework\MockObject\MockObject $provider2Mock */
-		$provider2Mock = $this->createMock(IBackendProvider::class);
-		$provider2Mock->expects($this->once())
-			->method('getBackends')
-			->willReturn([$backend2]);
-		$service->registerBackendProvider($provider2Mock);
-
-		$this->assertEquals($backend1a, $service->getBackend('identifier:\Foo\Bar'));
-		$this->assertEquals($backend1b, $service->getBackend('identifier:\Bar\Foo'));
-		$this->assertEquals($backend2, $service->getBackend('identifier:\Dead\Beef'));
-
-		$this->assertCount(3, $service->getBackends());
-	}
-
-	public function testUserMountingBackends(): void {
-		$this->appConfig->expects($this->once())
-			->method('getValueString')
-			->with('files_external', 'user_mounting_backends')
-			->willReturn('identifier:\User\Mount\Allowed,identifier_alias');
-		$this->appConfig->expects($this->once())
-			->method('getValueBool')
-			->with('files_external', 'allow_user_mounting')
-			->willReturn(true);
-
-		$service = new BackendService($this->appConfig);
-
-		$backendAllowed = $this->getBackendMock('\User\Mount\Allowed');
-		$backendAllowed->expects($this->never())
-			->method('removeVisibility');
-		$backendNotAllowed = $this->getBackendMock('\User\Mount\NotAllowed');
-		$backendNotAllowed->expects($this->once())
-			->method('removeVisibility')
-			->with(BackendService::VISIBILITY_PERSONAL);
-
-		$backendAlias = $this->getMockBuilder(Backend::class)
-			->disableOriginalConstructor()
-			->getMock();
-		$backendAlias->method('getIdentifierAliases')
-			->willReturn(['identifier_real', 'identifier_alias']);
-		$backendAlias->expects($this->never())
-			->method('removeVisibility');
-
-		$service->registerBackend($backendAllowed);
-		$service->registerBackend($backendNotAllowed);
-		$service->registerBackend($backendAlias);
-	}
-
-	public function testGetAvailableBackends(): void {
-		$service = new BackendService($this->appConfig);
-
-		$backendAvailable = $this->getBackendMock('\Backend\Available');
-		$backendAvailable->expects($this->once())
-			->method('checkDependencies')
-			->willReturn([]);
-		$backendNotAvailable = $this->getBackendMock('\Backend\NotAvailable');
-		$backendNotAvailable->expects($this->once())
-			->method('checkDependencies')
-			->willReturn([
-				$this->getMockBuilder('\OCA\Files_External\Lib\MissingDependency')
-					->disableOriginalConstructor()
-					->getMock()
-			]);
-
-		$service->registerBackend($backendAvailable);
-		$service->registerBackend($backendNotAvailable);
-
-		$availableBackends = $service->getAvailableBackends();
-		$this->assertArrayHasKey('identifier:\Backend\Available', $availableBackends);
-		$this->assertArrayNotHasKey('identifier:\Backend\NotAvailable', $availableBackends);
-	}
-
-	public function invalidConfigPlaceholderProvider() {
-		return [
-			[['@user']],
-			[['$user']],
-			[['hællo']],
-			[['spa ce']],
-			[['yo\o']],
-			[['<script>…</script>']],
-			[['xxyoloxx', 'invÆlid']],
-			[['tautology', 'tautology']],
-			[['tautology2', 'TAUTOLOGY2']],
-		];
-	}
-
-	/**
-	 * @dataProvider invalidConfigPlaceholderProvider
-	 */
-	public function testRegisterConfigHandlerInvalid(array $placeholders): void {
-		$this->expectException(\RuntimeException::class);
-
-		$service = new BackendService($this->appConfig);
-		$mock = $this->createMock(IConfigHandler::class);
-		$cb = function () use ($mock) {
-			return $mock;
-		};
-		foreach ($placeholders as $placeholder) {
-			$service->registerConfigHandler($placeholder, $cb);
-		}
-	}
-
-	public function testConfigHandlers(): void {
-		$service = new BackendService($this->appConfig);
-		$mock = $this->createMock(IConfigHandler::class);
-		$mock->expects($this->exactly(3))
-			->method('handle');
-		$cb = function () use ($mock) {
-			return $mock;
-		};
-		$service->registerConfigHandler('one', $cb);
-		$service->registerConfigHandler('2', $cb);
-		$service->registerConfigHandler('Three', $cb);
-
-		/** @var IConfigHandler[] $handlers */
-		$handlers = $service->getConfigHandlers();
-
-		foreach ($handlers as $handler) {
-			$handler->handle('Something');
-		}
-	}
+    /** @var IAppConfig|\PHPUnit\Framework\MockObject\MockObject */
+    protected $appConfig;
+
+    protected function setUp(): void {
+        $this->appConfig = $this->createMock(IAppConfig::class);
+    }
+
+    /**
+     * @param string $class
+     *
+     * @return \OCA\Files_External\Lib\Backend\Backend|\PHPUnit\Framework\MockObject\MockObject
+     */
+    protected function getBackendMock($class) {
+        $backend = $this->getMockBuilder(Backend::class)
+            ->disableOriginalConstructor()
+            ->getMock();
+        $backend->method('getIdentifier')->willReturn('identifier:' . $class);
+        $backend->method('getIdentifierAliases')->willReturn(['identifier:' . $class]);
+        return $backend;
+    }
+
+    /**
+     * @param string $class
+     *
+     * @return AuthMechanism|\PHPUnit\Framework\MockObject\MockObject
+     */
+    protected function getAuthMechanismMock($class) {
+        $backend = $this->getMockBuilder(AuthMechanism::class)
+            ->disableOriginalConstructor()
+            ->getMock();
+        $backend->method('getIdentifier')->willReturn('identifier:' . $class);
+        $backend->method('getIdentifierAliases')->willReturn(['identifier:' . $class]);
+        return $backend;
+    }
+
+    public function testRegisterBackend(): void {
+        $service = new BackendService($this->appConfig);
+
+        $backend = $this->getBackendMock('\Foo\Bar');
+
+        /** @var \OCA\Files_External\Lib\Backend\Backend|\PHPUnit\Framework\MockObject\MockObject $backendAlias */
+        $backendAlias = $this->getMockBuilder(Backend::class)
+            ->disableOriginalConstructor()
+            ->getMock();
+        $backendAlias->method('getIdentifierAliases')
+            ->willReturn(['identifier_real', 'identifier_alias']);
+        $backendAlias->method('getIdentifier')
+            ->willReturn('identifier_real');
+
+        $service->registerBackend($backend);
+        $service->registerBackend($backendAlias);
+
+        $this->assertEquals($backend, $service->getBackend('identifier:\Foo\Bar'));
+        $this->assertEquals($backendAlias, $service->getBackend('identifier_real'));
+        $this->assertEquals($backendAlias, $service->getBackend('identifier_alias'));
+
+        $backends = $service->getBackends();
+        $this->assertCount(2, $backends);
+        $this->assertArrayHasKey('identifier:\Foo\Bar', $backends);
+        $this->assertArrayHasKey('identifier_real', $backends);
+        $this->assertArrayNotHasKey('identifier_alias', $backends);
+    }
+
+    public function testBackendProvider(): void {
+        $service = new BackendService($this->appConfig);
+
+        $backend1 = $this->getBackendMock('\Foo\Bar');
+        $backend2 = $this->getBackendMock('\Bar\Foo');
+
+        /** @var IBackendProvider|\PHPUnit\Framework\MockObject\MockObject $providerMock */
+        $providerMock = $this->createMock(IBackendProvider::class);
+        $providerMock->expects($this->once())
+            ->method('getBackends')
+            ->willReturn([$backend1, $backend2]);
+        $service->registerBackendProvider($providerMock);
+
+        $this->assertEquals($backend1, $service->getBackend('identifier:\Foo\Bar'));
+        $this->assertEquals($backend2, $service->getBackend('identifier:\Bar\Foo'));
+
+        $this->assertCount(2, $service->getBackends());
+    }
+
+    public function testAuthMechanismProvider(): void {
+        $service = new BackendService($this->appConfig);
+
+        $backend1 = $this->getAuthMechanismMock('\Foo\Bar');
+        $backend2 = $this->getAuthMechanismMock('\Bar\Foo');
+
+        /** @var IAuthMechanismProvider|\PHPUnit\Framework\MockObject\MockObject $providerMock */
+        $providerMock = $this->createMock(IAuthMechanismProvider::class);
+        $providerMock->expects($this->once())
+            ->method('getAuthMechanisms')
+            ->willReturn([$backend1, $backend2]);
+        $service->registerAuthMechanismProvider($providerMock);
+
+        $this->assertEquals($backend1, $service->getAuthMechanism('identifier:\Foo\Bar'));
+        $this->assertEquals($backend2, $service->getAuthMechanism('identifier:\Bar\Foo'));
+
+        $this->assertCount(2, $service->getAuthMechanisms());
+    }
+
+    public function testMultipleBackendProviders(): void {
+        $service = new BackendService($this->appConfig);
+
+        $backend1a = $this->getBackendMock('\Foo\Bar');
+        $backend1b = $this->getBackendMock('\Bar\Foo');
+
+        $backend2 = $this->getBackendMock('\Dead\Beef');
+
+        /** @var IBackendProvider|\PHPUnit\Framework\MockObject\MockObject $provider1Mock */
+        $provider1Mock = $this->createMock(IBackendProvider::class);
+        $provider1Mock->expects($this->once())
+            ->method('getBackends')
+            ->willReturn([$backend1a, $backend1b]);
+        $service->registerBackendProvider($provider1Mock);
+        /** @var IBackendProvider|\PHPUnit\Framework\MockObject\MockObject $provider2Mock */
+        $provider2Mock = $this->createMock(IBackendProvider::class);
+        $provider2Mock->expects($this->once())
+            ->method('getBackends')
+            ->willReturn([$backend2]);
+        $service->registerBackendProvider($provider2Mock);
+
+        $this->assertEquals($backend1a, $service->getBackend('identifier:\Foo\Bar'));
+        $this->assertEquals($backend1b, $service->getBackend('identifier:\Bar\Foo'));
+        $this->assertEquals($backend2, $service->getBackend('identifier:\Dead\Beef'));
+
+        $this->assertCount(3, $service->getBackends());
+    }
+
+    public function testUserMountingBackends(): void {
+        $this->appConfig->expects($this->once())
+            ->method('getValueString')
+            ->with('files_external', 'user_mounting_backends')
+            ->willReturn('identifier:\User\Mount\Allowed,identifier_alias');
+        $this->appConfig->expects($this->once())
+            ->method('getValueBool')
+            ->with('files_external', 'allow_user_mounting')
+            ->willReturn(true);
+
+        $service = new BackendService($this->appConfig);
+
+        $backendAllowed = $this->getBackendMock('\User\Mount\Allowed');
+        $backendAllowed->expects($this->never())
+            ->method('removeVisibility');
+        $backendNotAllowed = $this->getBackendMock('\User\Mount\NotAllowed');
+        $backendNotAllowed->expects($this->once())
+            ->method('removeVisibility')
+            ->with(BackendService::VISIBILITY_PERSONAL);
+
+        $backendAlias = $this->getMockBuilder(Backend::class)
+            ->disableOriginalConstructor()
+            ->getMock();
+        $backendAlias->method('getIdentifierAliases')
+            ->willReturn(['identifier_real', 'identifier_alias']);
+        $backendAlias->expects($this->never())
+            ->method('removeVisibility');
+
+        $service->registerBackend($backendAllowed);
+        $service->registerBackend($backendNotAllowed);
+        $service->registerBackend($backendAlias);
+    }
+
+    public function testGetAvailableBackends(): void {
+        $service = new BackendService($this->appConfig);
+
+        $backendAvailable = $this->getBackendMock('\Backend\Available');
+        $backendAvailable->expects($this->once())
+            ->method('checkDependencies')
+            ->willReturn([]);
+        $backendNotAvailable = $this->getBackendMock('\Backend\NotAvailable');
+        $backendNotAvailable->expects($this->once())
+            ->method('checkDependencies')
+            ->willReturn([
+                $this->getMockBuilder('\OCA\Files_External\Lib\MissingDependency')
+                    ->disableOriginalConstructor()
+                    ->getMock()
+            ]);
+
+        $service->registerBackend($backendAvailable);
+        $service->registerBackend($backendNotAvailable);
+
+        $availableBackends = $service->getAvailableBackends();
+        $this->assertArrayHasKey('identifier:\Backend\Available', $availableBackends);
+        $this->assertArrayNotHasKey('identifier:\Backend\NotAvailable', $availableBackends);
+    }
+
+    public function invalidConfigPlaceholderProvider() {
+        return [
+            [['@user']],
+            [['$user']],
+            [['hællo']],
+            [['spa ce']],
+            [['yo\o']],
+            [['<script>…</script>']],
+            [['xxyoloxx', 'invÆlid']],
+            [['tautology', 'tautology']],
+            [['tautology2', 'TAUTOLOGY2']],
+        ];
+    }
+
+    /**
+     * @dataProvider invalidConfigPlaceholderProvider
+     */
+    public function testRegisterConfigHandlerInvalid(array $placeholders): void {
+        $this->expectException(\RuntimeException::class);
+
+        $service = new BackendService($this->appConfig);
+        $mock = $this->createMock(IConfigHandler::class);
+        $cb = function () use ($mock) {
+            return $mock;
+        };
+        foreach ($placeholders as $placeholder) {
+            $service->registerConfigHandler($placeholder, $cb);
+        }
+    }
+
+    public function testConfigHandlers(): void {
+        $service = new BackendService($this->appConfig);
+        $mock = $this->createMock(IConfigHandler::class);
+        $mock->expects($this->exactly(3))
+            ->method('handle');
+        $cb = function () use ($mock) {
+            return $mock;
+        };
+        $service->registerConfigHandler('one', $cb);
+        $service->registerConfigHandler('2', $cb);
+        $service->registerConfigHandler('Three', $cb);
+
+        /** @var IConfigHandler[] $handlers */
+        $handlers = $service->getConfigHandlers();
+
+        foreach ($handlers as $handler) {
+            $handler->handle('Something');
+        }
+    }
 }