Proper exceptions and Initial NetworkStream implementation.

src/Application.php

@@ -3,6 +3,8 @@ namespace Misuzu;
 
 use Aitemu\RouteCollection;
 use Misuzu\Config\ConfigManager;
+use UnexpectedValueException;
+use InvalidArgumentException;
 
 /**
  * Handles the set up procedures.
@@ -51,7 +53,7 @@ class Application extends ApplicationBase
     public function startDatabase(): void
     {
         if ($this->hasDatabase) {
-            throw new \Exception('Database module has already been started.');
+            throw new UnexpectedValueException('Database module has already been started.');
         }
 
         $this->addModule('database', new Database($this->config, self::DATABASE_CONNECTIONS[0]));
@@ -70,7 +72,7 @@ class Application extends ApplicationBase
             $section = 'Database.' . $name;
 
             if (!$config->contains($section)) {
-                throw new \Exception("Database {$name} is not configured.");
+                throw new InvalidArgumentException("Database {$name} is not configured.");
             }
 
             $database->addConnectionFromConfig($section, $name);
@@ -83,7 +85,7 @@ class Application extends ApplicationBase
     public function startTemplating(): void
     {
         if ($this->hasTemplating) {
-            throw new \Exception('Templating module has already been started.');
+            throw new UnexpectedValueException('Templating module has already been started.');
         }
 
         $this->addModule('templating', $twig = new TemplateEngine);
@@ -110,7 +112,7 @@ class Application extends ApplicationBase
     public function startRouter(array $routes = null): void
     {
         if ($this->hasRouter) {
-            throw new \Exception('Router module has already been started.');
+            throw new UnexpectedValueException('Router module has already been started.');
         }
 
         $this->addModule('router', $router = new RouteCollection);

src/ApplicationBase.php

@@ -1,6 +1,9 @@
 <?php
 namespace Misuzu;
 
+use InvalidArgumentException;
+use UnexpectedValueException;
+
 /**
  * Contains all non-specific methods, for possibly using Misuzu as a framework for other things.
  */
@@ -25,7 +28,7 @@ abstract class ApplicationBase
     public static function getInstance(): ApplicationBase
     {
         if (is_null(self::$instance) || !(self::$instance instanceof ApplicationBase)) {
-            throw new \Exception('Invalid instance type.');
+            throw new UnexpectedValueException('Invalid instance type.');
         }
 
         return self::$instance;
@@ -39,7 +42,7 @@ abstract class ApplicationBase
     public static function start(...$params): ApplicationBase
     {
         if (!is_null(self::$instance) || self::$instance instanceof ApplicationBase) {
-            throw new \Exception('An Application has already been set up.');
+            throw new UnexpectedValueException('An Application has already been set up.');
         }
 
         self::$instance = new static(...$params);
@@ -86,7 +89,7 @@ abstract class ApplicationBase
             return $this->modules[$name];
         }
 
-        throw new \Exception('Invalid property.');
+        throw new InvalidArgumentException('Invalid property.');
     }
 
     /**
@@ -97,7 +100,7 @@ abstract class ApplicationBase
     public function addModule(string $name, $module): void
     {
         if ($this->hasModule($name)) {
-            throw new \Exception('This module has already been registered.');
+            throw new InvalidArgumentException('This module has already been registered.');
         }
 
         $this->modules[$name] = $module;

src/Colour.php

@@ -1,6 +1,8 @@
 <?php
 namespace Misuzu;
 
+use InvalidArgumentException;
+
 class Colour
 {
     private const INHERIT = 0x40000000;
@@ -106,7 +108,7 @@ class Colour
         if ($hex_length === 3) {
             $hex = $hex[0] . $hex[0] . $hex[1] . $hex[1] . $hex[2] . $hex[2];
         } elseif ($hex_length != 6) {
-            throw new \Exception('Invalid hex colour format! (find a more appropiate exception type)');
+            throw new InvalidArgumentException('Invalid hex colour format!');
         }
 
         return static::fromRGB(

src/Database.php

@@ -3,6 +3,7 @@ namespace Misuzu;
 
 use Illuminate\Database\Capsule\Manager as LaravelDatabaseManager;
 use Misuzu\Config\ConfigManager;
+use InvalidArgumentException;
 
 class Database extends LaravelDatabaseManager
 {
@@ -44,13 +45,13 @@ class Database extends LaravelDatabaseManager
     public function addConnectionFromConfig(string $section, string $name = 'default'): void
     {
         if (!$this->configManager->contains($section, 'driver')) {
-            throw new \Exception('Config section not found!');
+            throw new InvalidArgumentException('Config section not found!');
         }
 
         $driver = $this->configManager->get($section, 'driver');
 
         if (!in_array($driver, self::SUPPORTED_DB_ALS)) {
-            throw new \Exception('Unsupported driver.');
+            throw new InvalidArgumentException('Unsupported driver.');
         }
 
         $args = [

src/IO/FileStream.php

@@ -221,7 +221,6 @@ class FileStream extends Stream
 
     public function writeChar(int $char): void
     {
-        $this->ensureHandleActive();
         $this->write(chr($char), 0, 1);
     }
 

src/IO/NetworkStream.php

@@ -0,0 +1,149 @@
+<?php
+namespace Misuzu\IO;
+
+class NetworkStream extends Stream
+{
+    protected $resourceHandle;
+    protected $host;
+    protected $port;
+    protected $timeout;
+
+    public function __construct(string $host, int $port = -1, ?int $timeout = null)
+    {
+        $this->host = $host;
+        $this->port = $port;
+        $this->timeout = $timeout ?? (int)ini_get('default_socket_timeout');
+
+        try {
+            $this->resourceHandle = fsockopen($this->host, $this->port, $errno, $errstr, $this->timeout);
+        } catch (ErrorException $ex) {
+            throw new IOException($ex->getMessage());
+        }
+
+        if ($this->resourceHandle === false) {
+            throw new IOException("[{$errno}] {$errstr}");
+        }
+
+        $this->ensureHandleActive();
+    }
+
+    public function __destruct()
+    {
+        if (!is_resource($this->resourceHandle)) {
+            return;
+        }
+
+        $this->close();
+    }
+
+    public function getResource(): resource
+    {
+        $this->ensureHandleActive();
+        return $this->resourceHandle;
+    }
+
+    protected function ensureHandleActive(): void
+    {
+        if (!is_resource($this->resourceHandle)) {
+            throw new IOException("No active file handle.");
+        }
+    }
+
+    protected function getCanRead(): bool
+    {
+        return true;
+    }
+
+    protected function getCanSeek(): bool
+    {
+        return false;
+    }
+
+    protected function getCanTimeout(): bool
+    {
+        return true;
+    }
+
+    protected function getCanWrite(): bool
+    {
+        return true;
+    }
+
+    protected function getLength(): int
+    {
+        return -1;
+    }
+
+    protected function getPosition(): int
+    {
+        return -1;
+    }
+
+    protected function getReadTimeout(): int
+    {
+        return -1;
+    }
+
+    protected function getWriteTimeout(): int
+    {
+        return -1;
+    }
+
+    public function flush(): void
+    {
+        $this->ensureHandleActive();
+        fflush($this->resourceHandle);
+    }
+
+    public function close(): void
+    {
+        $this->ensureHandleActive();
+        fclose($this->resourceHandle);
+    }
+
+    public function read(int $length): string
+    {
+        $this->ensureHandleActive();
+
+        $read = fread($this->resourceHandle, $length);
+
+        if ($read === false) {
+            throw new IOException('Read failed.');
+        }
+
+        return $read;
+    }
+
+    public function readChar(): int
+    {
+        $this->ensureHandleActive();
+
+        return ord(fgetc($this->resourceHandle));
+    }
+
+    public function write(string $data): int
+    {
+        $this->ensureHandleActive();
+
+        $write = fwrite($this->resourceHandle, $data);
+
+        if ($write === false) {
+            throw new IOException('Write failed.');
+        }
+
+        return $write;
+    }
+
+    public function writeChar(int $char): void
+    {
+        $this->write(chr($char), 0, 1);
+    }
+
+    /**
+     * @SuppressWarnings("unused")
+     */
+    public function seek(int $offset, int $origin): void
+    {
+        throw new IOException('This stream cannot perform seek operations.');
+    }
+}

src/IO/Stream.php

@@ -1,6 +1,8 @@
 <?php
 namespace Misuzu\IO;
 
+use InvalidArgumentException;
+
 abstract class Stream
 {
     public const ORIGIN_CURRENT = 0;
@@ -15,8 +17,7 @@ abstract class Stream
             return $this->{$name}();
         }
 
-        // todo: specialised exception type
+        throw new InvalidArgumentException;
-        throw new IOException('Invalid property.');
     }
 
     abstract protected function getCanRead(): bool;

src/Net/CIDR.php

@@ -1,6 +1,8 @@
 <?php
 namespace Misuzu\Net;
 
+use InvalidArgumentException;
+
 /**
  * CIDR functions.
  * @package Misuzu\Net
@@ -10,15 +12,15 @@ class CIDR
 {
     /**
      * Matches an IP to a CIDR range.
-     * @param string $ip
+     * @param string $ipAddr
      * @param string $range
      * @return bool
      */
-    public static function match(string $ip, string $range): bool
+    public static function match(string $ipAddr, string $range): bool
     {
         [$net, $mask] = explode('/', $range);
 
-        $ipv = IP::version($ip);
+        $ipv = IP::version($ipAddr);
         $rangev = IP::version($net);
 
         if (!$ipv || !$rangev || $ipv !== $rangev) {
@@ -27,44 +29,44 @@ class CIDR
 
         switch ($ipv) {
             case IP::V6:
-                return static::matchV6($ip, $net, $mask);
+                return static::matchV6($ipAddr, $net, $mask);
 
             case IP::V4:
-                return static::matchV4($ip, $net, $mask);
+                return static::matchV4($ipAddr, $net, $mask);
 
             default:
-                return false;
+                throw new InvalidArgumentException('Invalid IP type.');
         }
     }
 
     /**
      * Matches an IPv4 to a CIDR range.
-     * @param string $ip
+     * @param string $ipAddr
      * @param string $net
      * @param int $mask
      * @return bool
      */
-    private static function matchV4(string $ip, string $net, int $mask): bool
+    private static function matchV4(string $ipAddr, string $net, int $mask): bool
     {
-        $ip = ip2long($ip);
+        $ipAddr = ip2long($ipAddr);
         $net = ip2long($net);
         $mask = -1 << (32 - $mask);
-        return ($ip & $mask) === $net;
+        return ($ipAddr & $mask) === $net;
     }
 
     /**
      * Matches an IPv6 to a CIDR range.
-     * @param string $ip
+     * @param string $ipAddr
      * @param string $net
      * @param int $mask
      * @return bool
      */
-    private static function matchV6(string $ip, string $net, int $mask): bool
+    private static function matchV6(string $ipAddr, string $net, int $mask): bool
     {
-        $ip = inet_pton($ip);
+        $ipAddr = inet_pton($ipAddr);
         $net = inet_pton($net);
         $mask = static::createV6Mask($mask);
-        return ($ip & $mask) === $net;
+        return ($ipAddr & $mask) === $net;
     }
 
     /**

tests/ColourTest.php

@@ -3,6 +3,7 @@ namespace MisuzuTests;
 
 use PHPUnit\Framework\TestCase;
 use Misuzu\Colour;
+use InvalidArgumentException;
 
 class ColourTest extends TestCase
 {
@@ -79,4 +80,13 @@ class ColourTest extends TestCase
         $this->assertEquals($colour->blue, static::BLUE_HEX3);
         $this->assertFalse($colour->inherit);
     }
+
+    /**
+     * @expectedException InvalidArgumentException
+     * @expectedExceptionMessage Invalid hex colour format!
+     */
+    public function testHexException()
+    {
+        Colour::fromHex('invalid hex code');
+    }
 }