Add KML Validator

Author: danielebarbaro

src/Enums/GeometryType.php

@@ -0,0 +1,21 @@
+<?php
+
+namespace PlinCode\KmlParser\Enums;
+
+enum GeometryType: string
+{
+    case POINT = 'Point';
+    case LINE_STRING = 'LineString';
+    case POLYGON = 'Polygon';
+    case MULTI_GEOMETRY = 'MultiGeometry';
+
+    /**
+     * Get all values as array
+     *
+     * @return array<string>
+     */
+    public static function values(): array
+    {
+        return array_map(fn (self $type) => $type->value, self::cases());
+    }
+}

src/Enums/RequiredElement.php

@@ -0,0 +1,19 @@
+<?php
+
+namespace PlinCode\KmlParser\Enums;
+
+enum RequiredElement: string
+{
+    case KML = 'kml';
+    case DOCUMENT = 'Document';
+
+    /**
+     * Get all values as array
+     *
+     * @return array<string>
+     */
+    public static function values(): array
+    {
+        return array_map(fn (self $element) => $element->value, self::cases());
+    }
+}

src/Exceptions/KmlException.php

@@ -7,4 +7,4 @@
 class KmlException extends Exception
 {
     //
-} 
+}

src/Exceptions/KmlParserException.php

@@ -23,4 +23,4 @@ public static function failedToParse(string $message): self
     {
         return new self("Failed to parse KML content: {$message}");
     }
-} 
+}

src/Exceptions/KmzExtractorException.php

@@ -23,4 +23,4 @@ public static function invalidZipFile(string $path): self
     {
         return new self("Invalid KMZ file: {$path}");
     }
-} 
+}

src/KmlParser.php

@@ -5,6 +5,7 @@
 use Exception;
 use PlinCode\KmlParser\Exceptions\KmlParserException;
 use PlinCode\KmlParser\Traits\ParsesCoordinates;
+use PlinCode\KmlParser\Validators\KmlValidator;
 use SimpleXMLElement;
 
 class KmlParser
@@ -15,9 +16,12 @@ class KmlParser
 
     protected string $namespace = 'http://www.opengis.net/kml/2.2';
 
+    protected KmlValidator $validator;
+
     public function __construct()
     {
         $this->namespace = config('kml-parser.namespace', $this->namespace);
+        $this->validator = new KmlValidator;
     }
 
     /**
@@ -41,9 +45,9 @@ public function loadFromFile(string $path): self
      */
     public function loadFromString(string $content): self
     {
-        libxml_use_internal_errors(true);
-
         try {
+            $this->validator->validate($content);
+            libxml_use_internal_errors(true);
             $this->xml = new SimpleXMLElement($content);
 
             $errors = libxml_get_errors();

src/Validators/KmlValidator.php

@@ -0,0 +1,106 @@
+<?php
+
+namespace PlinCode\KmlParser\Validators;
+
+use PlinCode\KmlParser\Enums\GeometryType;
+use PlinCode\KmlParser\Exceptions\KmlException;
+use SimpleXMLElement;
+
+class KmlValidator
+{
+    protected string $namespace = 'http://www.opengis.net/kml/2.2';
+
+    protected SimpleXMLElement $xml;
+
+    public function validate(string $content): void
+    {
+        libxml_use_internal_errors(true);
+
+        try {
+            $this->xml = new SimpleXMLElement($content);
+
+            $namespaces = $this->xml->getDocNamespaces();
+            if (! isset($namespaces['']) || $namespaces[''] !== $this->namespace) {
+                throw new KmlException('Invalid or missing KML namespace');
+            }
+
+            $this->xml->registerXPathNamespace('kml', $this->namespace);
+
+            if (empty($this->xml->Document)) {
+                throw new KmlException('Missing required element: Document');
+            }
+
+            $placemarks = $this->xml->xpath('//kml:Placemark');
+            if (! empty($placemarks)) {
+                foreach ($placemarks as $placemark) {
+                    $this->validatePlacemark($placemark);
+                }
+            }
+        } catch (KmlException $e) {
+            throw $e;
+        } catch (\Exception $e) {
+            throw new KmlException('Invalid KML content: '.$e->getMessage());
+        } finally {
+            libxml_clear_errors();
+        }
+    }
+
+    protected function validatePlacemark(SimpleXMLElement $placemark): void
+    {
+        $hasGeometry = false;
+        foreach (GeometryType::cases() as $type) {
+            if ($placemark->{$type->value}) {
+                $hasGeometry = true;
+                $this->validateGeometryCoordinates($placemark->{$type->value}, $type->value);
+                break;
+            }
+        }
+
+        if (! $hasGeometry) {
+            throw new KmlException('Found Placemark without valid geometry');
+        }
+    }
+
+    protected function validateGeometryCoordinates(SimpleXMLElement $geometry, string $type): void
+    {
+        if ($type === 'Polygon') {
+            if (empty($geometry->outerBoundaryIs->LinearRing->coordinates)) {
+                throw new KmlException('Empty coordinates in Polygon geometry');
+            }
+            $coordinates = (string) $geometry->outerBoundaryIs->LinearRing->coordinates;
+        } else {
+            if (empty($geometry->coordinates)) {
+                throw new KmlException('Empty coordinates in geometry');
+            }
+            $coordinates = (string) $geometry->coordinates;
+        }
+
+        if (empty(trim($coordinates))) {
+            throw new KmlException('Empty coordinates in geometry');
+        }
+
+        $coords = preg_split('/\s+/', trim($coordinates));
+        foreach ($coords as $coord) {
+            if (empty(trim($coord))) {
+                continue;
+            }
+
+            $parts = explode(',', trim($coord));
+            if (count($parts) < 2 || count($parts) > 3) {
+                throw new KmlException('Invalid coordinate format');
+            }
+
+            if (! is_numeric($parts[0]) || $parts[0] < -180 || $parts[0] > 180) {
+                throw new KmlException("Invalid longitude value: {$parts[0]}");
+            }
+
+            if (! is_numeric($parts[1]) || $parts[1] < -90 || $parts[1] > 90) {
+                throw new KmlException("Invalid latitude value: {$parts[1]}");
+            }
+
+            if (isset($parts[2]) && ! is_numeric($parts[2])) {
+                throw new KmlException("Invalid altitude value: {$parts[2]}");
+            }
+        }
+    }
+}

tests/ExceptionsTest.php

@@ -7,51 +7,51 @@
 
 it('throws exception when KML file not found', function () {
     $parser = new KmlParser;
-    
+
     $parser->loadFromFile('non-existent.kml');
 })->throws(KmlParserException::class, 'KML file not found: non-existent.kml');
 
 it('throws exception when no KML data loaded', function () {
     $parser = new KmlParser;
-    
+
     $parser->getPlacemarks();
 })->throws(KmlParserException::class, 'No KML data loaded');
 
 it('throws exception on invalid XML', function () {
     $parser = new KmlParser;
-    
+
     $parser->loadFromString('invalid xml content');
 })->throws(KmlParserException::class, 'Failed to parse KML content');
 
 it('throws exception when KMZ file not found', function () {
     $extractor = new KmzExtractor;
-    
+
     $extractor->extractKmlContent('non-existent.kmz');
 })->throws(KmzExtractorException::class, 'KMZ file not found: non-existent.kmz');
 
 it('throws exception when KMZ file is invalid', function () {
     $extractor = new KmzExtractor;
-    
+
     // Create an empty file
     file_put_contents(__DIR__.'/files/invalid.kmz', 'not a zip file');
-    
+
     $extractor->extractKmlContent(__DIR__.'/files/invalid.kmz');
 })->throws(KmzExtractorException::class, 'Invalid KMZ file');
 
 it('throws exception when no KML found in KMZ', function () {
     $extractor = new KmzExtractor;
-    
+
     // Create a valid zip file without KML
     $zip = new ZipArchive;
     $zip->open(__DIR__.'/files/no-kml.kmz', ZipArchive::CREATE);
     $zip->addFromString('test.txt', 'test content');
     $zip->close();
-    
+
     $extractor->extractKmlContent(__DIR__.'/files/no-kml.kmz');
 })->throws(KmzExtractorException::class, 'No KML file found in KMZ archive');
 
 afterEach(function () {
     // Cleanup test files
     @unlink(__DIR__.'/files/invalid.kmz');
     @unlink(__DIR__.'/files/no-kml.kmz');
-}); 
+});