The goal is to develop a unique Reader class that functions as a wrapper for the League Flysystem documentation
The purpose of the Reader is to provide a convenient way of reading all files in a directory, regardless of their physical form (local file or file in an archive).
Due to dependency injection (DI), the wrapper should not create instances of dependencies internally. Instead, it should accept these dependencies as arguments in its constructor or other setter methods.
Here's an example usage of League Flysystem on its own (without the aforementioned wrapper) to read a regular file from disk:
<?php
use League\Flysystem\Filesystem;
use League\Flysystem\Adapter\Local;
$adapter = new Local(__DIR__.'/path/to/root');
$filesystem = new Filesystem($adapter);
$content = $filesystem->read('path-to-file.txt');
As you can see, first an adapter Local is created, requiring a path in its constructor. Then a filesystem object is created, which requires an instance of the adapter in its constructor.
Both Filesystem and Local require mandatory arguments. These arguments must be provided when creating objects from these classes, and there are no public setters available for these arguments.
My question is: How can I write the Reader class that wraps Filesystem and Local by using Dependency Injection?
Normally, I would do something similar to this:
<?php
use League\Flysystem\FilesystemInterface;
use League\Flysystem\AdapterInterface;
class Reader
{
private $filesystem;
private $adapter
public function __construct(FilesystemInterface $filesystem,
AdapterInterface $adapter)
{
$this->filesystem = $filesystem;
$this->adapter = $adapter;
}
public function readContents(string $pathToDirWithFiles)
{
/**
* Uses $this->filesystem and $this->adapter
*
* Finds all files in the directory tree
* Reads all files
* Combines and returns their content
*/
}
}
// Usage of the Reader class
$reader = new Reader(new Filesytem, new Local);
$pathToDir = 'someDir/';
$contentsOfAllFiles = $reader->readContents($pathToDir);
// Later usage of the same reader object
$contentsOfAllFiles = $reader->readContents($differentPathToDir);
However, this approach won't work because I need to pass a Local adapter to the Filesystem constructor. In order to do that, I would have to pass the path to the Local adapter first, which goes against the whole purpose of the Reader's convenience — simply providing the directory path where all the files are located and having the Reader handle everything needed to retrieve the content of these files through the readContents() method.
So, I'm currently at an impasse. Is it possible to achieve a Reader as a wrapper for Filesystem and its Local adapter?
I want to avoid tight coupling, where I use the "new" keyword to directly instantiate dependencies in the Reader class:
<?php
use League\Flysystem\Filesystem;
use League\Flysystem\Adapter\Local;
class Reader
{
public function __construct()
{
}
public function readContents(string $pathToDirWithFiles)
{
$adapter = new Local($pathToDirWithFiles);
$filesystem = new Filesystem($adapter);
/**
* Perform directory listing, content reading,
* and return the results.
*/
}
}
Questions:
Is there any way to write a wrapper that uses Filesystem and Local as dependencies through Dependency Injection?
Are there any patterns other than the wrapper (adapter) approach that would help in constructing the Reader class without tightly coupling it to Filesystem and Local?
If we momentarily forget about the Reader class altogether: If Filesystem requires an instance of Local in its constructor, while Local requires a string (representing the path to a directory) in its constructor, is it possible to utilize these classes within a Dependency Injection Container (DIC) such as Symfony or Pimple in a reasonable manner?