Added new Utilities

Author: le0daniel

.gitignore

@@ -1 +1,3 @@
 .idea
+vendor
+composer.lock

composer.json

@@ -21,8 +21,10 @@
     }
   },
   "require": {
-    "php": "^7.2",
+    "php": "^7.4",
     "laravel/framework": "^7",
-    "intervention/image": "^2.5"
+    "intervention/image": "^2.5",
+    "nesbot/carbon": "^2.36",
+    "ext-json": "*"
   }
 }

src/Image/ImageRepresentation.php

@@ -0,0 +1,150 @@
+<?php
+
+namespace le0daniel\Laravel\ImageEngine\Image;
+
+use Carbon\Carbon;
+use le0daniel\Laravel\ImageEngine\Utility\Arrays;
+use le0daniel\Laravel\ImageEngine\Utility\Base64;
+use le0daniel\Laravel\ImageEngine\Utility\Json;
+
+/**
+ * Class ImageRepresentation
+ * @package le0daniel\Laravel\ImageEngine\Image
+ *
+ * @property-read string $filePath
+ * @property-read string $size
+ * @property-read null|int $expires
+ * @property-read null|Carbon $expiresCarbon
+ * @property-read string $diskName
+ * @property-read int|null $timestamp
+ * @property-read string $extension
+ * @property-read bool $isConfidential
+ * @property-read bool $isExpired
+ */
+final class ImageRepresentation
+{
+    private const DEFAULT_DISK_NAME = 'local';
+    private const SERIALIZE_KEY_MAP = [
+        'filePath' => 'p',
+        'size' => 's',
+        'expires' => 'e',
+        'diskName' => 'd',
+    ];
+    private const IMAGE_CACHE_MAX_AGE = 31557600;
+    private array $attributes;
+
+    private function __construct(array $attributes)
+    {
+        $this->attributes = $attributes;
+    }
+
+    /**
+     * @param string $filePath
+     * @param string $size
+     * @param null|Carbon|int $expires
+     * @param string $diskName
+     * @return static
+     */
+    public static function from(
+        string $filePath,
+        string $size,
+        $expires = null,
+        string $diskName = self::DEFAULT_DISK_NAME
+    ): self {
+        return new self(
+            [
+                'filePath' => $filePath,
+                'size' => $size,
+                'expires' => $expires instanceof Carbon
+                    ? $expires->getTimestamp()
+                    : $expires,
+                'diskName' => $diskName === self::DEFAULT_DISK_NAME
+                    ? null
+                    : $diskName
+                ,
+            ]
+        );
+    }
+
+    public static function fromSerialized(string $serialized): self
+    {
+        $mappedAttributes = Json::decode(Base64::urlDecode($serialized), ['e' => null, 'd' => null]);
+        $attributes = Arrays::mapKeys(
+            $mappedAttributes,
+            array_flip(self::SERIALIZE_KEY_MAP)
+        );
+        return new self($attributes);
+    }
+
+    public function __set($name, $value)
+    {
+        throw new \RuntimeException("Can not modify immutable ImageRepresentation. Tried to modify `{$name}`");
+    }
+
+    public function __isset(string $name)
+    {
+        return array_key_exists($name, $this->attributes);
+    }
+
+    private function getValue(string $name, $value)
+    {
+        switch ($name) {
+            case 'timestamp':
+                return $this->expires;
+            case 'disk':
+                return $value ?? self::DEFAULT_DISK_NAME;
+            case 'extension':
+                return pathinfo($this->filePath, PATHINFO_EXTENSION);
+            case 'isConfidential':
+                return (bool)$this->expires;
+            case 'isExpired':
+                return $this->isConfidential ? $this->expiresCarbon->isPast() : false;
+        }
+
+        return $value;
+    }
+
+    private function timeToExpireInSeconds(): int
+    {
+        return $this->isConfidential
+            ? $this->expires - time()
+            : self::IMAGE_CACHE_MAX_AGE;
+    }
+
+    public function cacheControlHeaders(): array
+    {
+        $maxAgeInSeconds = min($this->timeToExpireInSeconds(), self::IMAGE_CACHE_MAX_AGE);
+
+        return [
+            'Cache-Control' => "max-age={$maxAgeInSeconds}, public",
+        ];
+    }
+
+    public function __get(string $name)
+    {
+        return $this->__isset($name)
+            ? $this->getValue($name, $this->attributes[$name])
+            : $this->getValue($name, null);
+    }
+
+    public function toArray()
+    {
+        $array = Arrays::removeNullValues(
+            Arrays::mapKeys($this->attributes, self::SERIALIZE_KEY_MAP)
+        );
+        asort($array);
+        return $array;
+    }
+
+    public function serialize(): string
+    {
+        return Base64::urlEncode(
+            Json::encode($this->toArray())
+        );
+    }
+
+    public function dump()
+    {
+        var_dump($this->attributes);
+    }
+}

src/Utility/Arrays.php

@@ -0,0 +1,38 @@
+<?php
+
+declare(strict_types=1);
+
+namespace le0daniel\Laravel\ImageEngine\Utility;
+
+final class Arrays
+{
+    public static function mapKeys(array $array, array $keyMap): array
+    {
+        $mappedArray = [];
+
+        foreach ($array as $key => $value) {
+            $mappedKey = array_key_exists($key, $keyMap)
+                ? $keyMap[$key]
+                : $key;
+            $mappedArray[$mappedKey] = $value;
+        }
+
+        return $mappedArray;
+    }
+
+    public static function removeNullValues(array $array): array
+    {
+        return array_filter($array, fn($value) => !is_null($value));
+    }
+
+    public static function applyDefaultValues(array $array, array $defaultValues): array
+    {
+        foreach ($defaultValues as $key => $defaultValue) {
+            if (!array_key_exists($key, $array)) {
+                $array[$key] = $defaultValue;
+            }
+        }
+        return $array;
+    }
+
+}

src/Utility/Base64.php

@@ -0,0 +1,33 @@
+<?php
+
+declare(strict_types=1);
+
+namespace le0daniel\Laravel\ImageEngine\Utility;
+
+final class Base64
+{
+
+    public static function encode(string $string): string
+    {
+        return base64_encode($string);
+    }
+
+    public static function decode(string $encodedString): string
+    {
+        return base64_decode($encodedString);
+    }
+
+    public static function urlEncode(string $string): string
+    {
+        $urlSafe = strtr(self::encode($string), '+/', '-_');
+        return rtrim($urlSafe, '=');
+    }
+
+    public static function urlDecode(string $urlEncodedString): string
+    {
+        return self::decode(
+            strtr($urlEncodedString, '-_', '+/')
+        );
+    }
+
+}

src/Utility/Json.php

@@ -0,0 +1,23 @@
+<?php
+
+declare(strict_types=1);
+
+namespace le0daniel\Laravel\ImageEngine\Utility;
+
+final class Json
+{
+
+    public static function encode(array $data): string
+    {
+        return json_encode($data, JSON_THROW_ON_ERROR);
+    }
+
+    public static function decode(string $data, ?array $defaultValues): array
+    {
+        $data = json_decode($data, true, 512, JSON_THROW_ON_ERROR);
+        return $defaultValues
+            ? Arrays::applyDefaultValues($data, $defaultValues)
+            : $data;
+    }
+
+}

src/Utility/SignatureException.php

@@ -0,0 +1,8 @@
+<?php
+
+namespace le0daniel\Laravel\ImageEngine\Utility;
+
+final class SignatureException extends \Exception
+{
+
+}

src/Utility/Signatures.php

@@ -0,0 +1,44 @@
+<?php
+
+namespace le0daniel\Laravel\ImageEngine\Utility;
+
+final class Signatures
+{
+    private const SIGNATURE_REGEX = '/^[^:]*::[a-zA-Z0-9\-\_]+$/';
+
+    public static function sign(string $secret, string $stringToSign): string
+    {
+        $signature = self::calculateSignature($secret, $stringToSign);
+        return $stringToSign . '::' . Base64::urlEncode($signature);
+    }
+
+    public static function verifyAndReturnPayloadString(string $secret, string $signedString): string
+    {
+        self::verifyStructure($signedString);
+        [$payload, $userProvidedSignature] = explode('::', $signedString, 2);
+        self::verifySignature($secret, $payload, $userProvidedSignature);
+        return $payload;
+    }
+
+    private static function calculateSignature(string $secret, string $stringToSign): string
+    {
+        return hash_hmac('sha256', $stringToSign, $secret, true);
+    }
+
+    private static function verifyStructure(string $signedString): void
+    {
+        if (!preg_match(self::SIGNATURE_REGEX, $signedString, $matches, PREG_OFFSET_CAPTURE, 0)) {
+            throw new SignatureException('The signed string is of invalid structure');
+        }
+    }
+
+    private static function verifySignature(string $secret, $payload, $userProvidedSignature): void
+    {
+        $signature = self::calculateSignature($secret, $payload);
+
+        if (!hash_equals($signature, Base64::urlDecode($userProvidedSignature))) {
+            throw new SignatureException('Signature mismatches.');
+        }
+    }
+
+}