Make constructors private

CHANGELOG.md

@@ -8,6 +8,7 @@
 - `Innmind\Server\Status\Server::cpu()` now returns `Innmind\Immutable\Attempt<Innmind\Server\Status\Server\Cpu>`
 - `Innmind\Server\Status\Server::memory()` now returns `Innmind\Immutable\Attempt<Innmind\Server\Status\Server\Memory>`
 - `Innmind\Server\Status\Server::loadAverage()` now returns `Innmind\Immutable\Attempt<Innmind\Server\Status\Server\LoadAverage>`
+- `Innmind\Server\Status\Server\Logger` constructor is now private, use `::of()` instead
 
 ### Removed
 

src/Server/Disk/LoggerDisk.php

@@ -18,12 +18,17 @@ final class LoggerDisk implements Disk
     private Disk $disk;
     private LoggerInterface $logger;
 
-    public function __construct(Disk $disk, LoggerInterface $logger)
+    private function __construct(Disk $disk, LoggerInterface $logger)
     {
         $this->disk = $disk;
         $this->logger = $logger;
     }
 
+    public static function of(Disk $disk, LoggerInterface $logger): self
+    {
+        return new self($disk, $logger);
+    }
+
     #[\Override]
     public function volumes(): Set
     {

src/Server/Disk/UnixDisk.php

@@ -36,11 +36,16 @@ final class UnixDisk implements Disk
 
     private Processes $processes;
 
-    public function __construct(Processes $processes)
+    private function __construct(Processes $processes)
     {
         $this->processes = $processes;
     }
 
+    public static function of(Processes $processes): self
+    {
+        return new self($processes);
+    }
+
     #[\Override]
     public function volumes(): Set
     {

src/Server/Processes/LoggerProcesses.php

@@ -20,12 +20,17 @@ final class LoggerProcesses implements Processes
     private Processes $processes;
     private LoggerInterface $logger;
 
-    public function __construct(Processes $processes, LoggerInterface $logger)
+    private function __construct(Processes $processes, LoggerInterface $logger)
     {
         $this->processes = $processes;
         $this->logger = $logger;
     }
 
+    public static function of(Processes $processes, LoggerInterface $logger): self
+    {
+        return new self($processes, $logger);
+    }
+
     #[\Override]
     public function all(): Set
     {

src/Server/Processes/UnixProcesses.php

@@ -31,12 +31,17 @@ final class UnixProcesses implements Processes
     private Clock $clock;
     private Control\Processes $processes;
 
-    public function __construct(Clock $clock, Control\Processes $processes)
+    private function __construct(Clock $clock, Control\Processes $processes)
     {
         $this->clock = $clock;
         $this->processes = $processes;
     }
 
+    public static function of(Clock $clock, Control\Processes $processes): self
+    {
+        return new self($clock, $processes);
+    }
+
     #[\Override]
     public function all(): Set
     {

src/ServerFactory.php

@@ -18,8 +18,8 @@ public static function build(
         EnvironmentPath $path,
     ): Server {
         return match (\PHP_OS) {
-            'Darwin' => new OSX($clock, $control, $path),
-            'Linux' => new Linux($clock, $control),
+            'Darwin' => OSX::of($clock, $control, $path),
+            'Linux' => Linux::of($clock, $control),
             default => throw new \LogicException('Unsupported operating system '.\PHP_OS),
         };
     }

src/Servers/Linux.php

@@ -26,13 +26,18 @@ final class Linux implements Server
     private LoadAverageFacade $loadAverage;
     private UnixDisk $disk;
 
-    public function __construct(Clock $clock, Control $control)
+    private function __construct(Clock $clock, Control $control)
     {
         $this->cpu = new CpuFacade($control->processes());
         $this->memory = new MemoryFacade($control->processes());
-        $this->processes = new UnixProcesses($clock, $control->processes());
+        $this->processes = UnixProcesses::of($clock, $control->processes());
         $this->loadAverage = new LoadAverageFacade;
-        $this->disk = new UnixDisk($control->processes());
+        $this->disk = UnixDisk::of($control->processes());
+    }
+
+    public static function of(Clock $clock, Control $control): self
+    {
+        return new self($clock, $control);
     }
 
     #[\Override]

src/Servers/Logger.php

@@ -17,12 +17,17 @@ final class Logger implements Server
     private Server $server;
     private LoggerInterface $logger;
 
-    public function __construct(Server $server, LoggerInterface $logger)
+    private function __construct(Server $server, LoggerInterface $logger)
     {
         $this->server = $server;
         $this->logger = $logger;
     }
 
+    public static function of(Server $server, LoggerInterface $logger): self
+    {
+        return new self($server, $logger);
+    }
+
     #[\Override]
     public function cpu(): Attempt
     {
@@ -58,7 +63,7 @@ public function memory(): Attempt
     #[\Override]
     public function processes(): Processes
     {
-        return new Processes\LoggerProcesses(
+        return Processes\LoggerProcesses::of(
             $this->server->processes(),
             $this->logger,
         );
@@ -81,7 +86,7 @@ public function loadAverage(): Attempt
     #[\Override]
     public function disk(): Disk
     {
-        return new Disk\LoggerDisk(
+        return Disk\LoggerDisk::of(
             $this->server->disk(),
             $this->logger,
         );

src/Servers/OSX.php

@@ -27,13 +27,18 @@ final class OSX implements Server
     private LoadAverageFacade $loadAverage;
     private UnixDisk $disk;
 
-    public function __construct(Clock $clock, Control $control, EnvironmentPath $path)
+    private function __construct(Clock $clock, Control $control, EnvironmentPath $path)
     {
         $this->cpu = new CpuFacade($control->processes());
         $this->memory = new MemoryFacade($control->processes(), $path);
-        $this->processes = new UnixProcesses($clock, $control->processes());
+        $this->processes = UnixProcesses::of($clock, $control->processes());
         $this->loadAverage = new LoadAverageFacade;
-        $this->disk = new UnixDisk($control->processes());
+        $this->disk = UnixDisk::of($control->processes());
+    }
+
+    public static function of(Clock $clock, Control $control, EnvironmentPath $path): self
+    {
+        return new self($clock, $control, $path);
     }
 
     #[\Override]

tests/Server/Disk/LoggerDiskTest.php

@@ -23,22 +23,22 @@ class LoggerDiskTest extends TestCase
 {
     public function testInterface()
     {
-        $this->assertInstanceOf(Disk::class, new LoggerDisk(
+        $this->assertInstanceOf(Disk::class, LoggerDisk::of(
             $this->disk(),
             new NullLogger,
         ));
     }
 
     public function testVolumes()
     {
-        $disk = new LoggerDisk($this->disk(), new NullLogger);
+        $disk = LoggerDisk::of($this->disk(), new NullLogger);
 
         $this->assertInstanceOf(Set::class, $disk->volumes());
     }
 
     public function testGet()
     {
-        $disk = new LoggerDisk($this->disk(), new NullLogger);
+        $disk = LoggerDisk::of($this->disk(), new NullLogger);
 
         $this->assertInstanceOf(Volume::class, $disk->get(MountPoint::of('/'))->match(
             static fn($volume) => $volume,

tests/Server/Disk/UnixDiskTest.php

@@ -22,7 +22,7 @@ class UnixDiskTest extends TestCase
 
     public function setUp(): void
     {
-        $this->disk = new UnixDisk(
+        $this->disk = UnixDisk::of(
             Control::build(
                 Clock::live(),
                 IO::fromAmbientAuthority(),

tests/Server/Processes/LoggerProcessesTest.php

@@ -23,22 +23,22 @@ class LoggerProcessesTest extends TestCase
 {
     public function testInterface()
     {
-        $this->assertInstanceOf(Processes::class, new LoggerProcesses(
+        $this->assertInstanceOf(Processes::class, LoggerProcesses::of(
             $this->processes(),
             new NullLogger,
         ));
     }
 
     public function testAll()
     {
-        $processes = new LoggerProcesses($this->processes(), new NullLogger);
+        $processes = LoggerProcesses::of($this->processes(), new NullLogger);
 
         $this->assertInstanceOf(Set::class, $processes->all());
     }
 
     public function testGet()
     {
-        $processes = new LoggerProcesses($this->processes(), new NullLogger);
+        $processes = LoggerProcesses::of($this->processes(), new NullLogger);
 
         $this->assertInstanceOf(Process::class, $processes->get(Pid::of(1))->match(
             static fn($process) => $process,

tests/Server/Processes/UnixProcessesTest.php

@@ -25,7 +25,7 @@ class UnixProcessesTest extends TestCase
 
     public function setUp(): void
     {
-        $this->processes = new UnixProcesses(
+        $this->processes = UnixProcesses::of(
             Clock::live(),
             Control::build(
                 Clock::live(),

tests/Servers/LinuxTest.php

@@ -25,7 +25,7 @@ class LinuxTest extends TestCase
 
     public function setUp(): void
     {
-        $this->server = new Linux(
+        $this->server = Linux::of(
             Clock::live(),
             Control::build(
                 Clock::live(),

tests/Servers/LoggerTest.php

@@ -26,15 +26,15 @@ class LoggerTest extends TestCase
 {
     public function testInterface()
     {
-        $this->assertInstanceOf(Server::class, new Logger(
+        $this->assertInstanceOf(Server::class, Logger::of(
             $this->server(),
             new NullLogger,
         ));
     }
 
     public function testCpu()
     {
-        $server = new Logger($this->server(), new NullLogger);
+        $server = Logger::of($this->server(), new NullLogger);
 
         $this->assertInstanceOf(Cpu::class, $server->cpu()->match(
             static fn($cpu) => $cpu,
@@ -44,7 +44,7 @@ public function testCpu()
 
     public function testMemory()
     {
-        $server = new Logger($this->server(), new NullLogger);
+        $server = Logger::of($this->server(), new NullLogger);
 
         $this->assertInstanceOf(Memory::class, $server->memory()->match(
             static fn($memory) => $memory,
@@ -54,7 +54,7 @@ public function testMemory()
 
     public function testProcesses()
     {
-        $server = new Logger(
+        $server = Logger::of(
             $this->server(),
             new NullLogger,
         );
@@ -64,14 +64,14 @@ public function testProcesses()
 
     public function testLoadAverage()
     {
-        $server = new Logger($this->server(), new NullLogger);
+        $server = Logger::of($this->server(), new NullLogger);
 
         $this->assertInstanceOf(LoadAverage::class, $server->loadAverage()->unwrap());
     }
 
     public function testDisk()
     {
-        $server = new Logger(
+        $server = Logger::of(
             $this->server(),
             new NullLogger,
         );
@@ -81,7 +81,7 @@ public function testDisk()
 
     public function testTmp()
     {
-        $server = new Logger($this->server(), new NullLogger);
+        $server = Logger::of($this->server(), new NullLogger);
 
         $this->assertInstanceOf(Path::class, $server->tmp());
     }

tests/Servers/OSXTest.php

@@ -26,7 +26,7 @@ class OSXTest extends TestCase
 
     public function setUp(): void
     {
-        $this->server = new OSX(
+        $this->server = OSX::of(
             Clock::live(),
             Control::build(
                 Clock::live(),