Extend Schema exceptions to contain the file causing the error

Enno Woortmann · Enno Woortmann · commit eff48d9e3f0b · 2020-07-14T16:30:32.000+02:00
diff --git a/src/Model/Property/Property.php b/src/Model/Property/Property.php
@@ -60,11 +60,12 @@ class Property implements PropertyInterface
      */
     public function __construct(string $name, string $type, JsonSchema $jsonSchema, string $description = '')
     {
-        $this->attribute = $this->processAttributeName($name);
         $this->name = $name;
         $this->type = $type;
         $this->jsonSchema = $jsonSchema;
         $this->description = $description;
+
+        $this->attribute = $this->processAttributeName($name);
     }
 
     /**
@@ -260,7 +261,13 @@ function ($element) {
         $attributeName = lcfirst(join('', $elements));
 
         if (empty($attributeName)) {
-            throw new SchemaException("Property name '$name' results in an empty attribute name");
+            throw new SchemaException(
+                sprintf(
+                    "Property name '%s' results in an empty attribute name in file %s",
+                    $name,
+                    $this->jsonSchema->getFile()
+                )
+            );
         }
 
         return $attributeName;
diff --git a/src/Model/Schema.php b/src/Model/Schema.php
@@ -53,13 +53,13 @@ class Schema
      *
      * @param string $classPath
      * @param string $className
-     * @param JsonSchema|null $schema
+     * @param JsonSchema $schema
      * @param SchemaDefinitionDictionary|null $dictionary
      */
     public function __construct(
         string $classPath,
         string $className,
-        JsonSchema $schema = null,
+        JsonSchema $schema,
         SchemaDefinitionDictionary $dictionary = null
     ) {
         $this->className = $className;
diff --git a/src/Model/SchemaDefinition/SchemaDefinition.php b/src/Model/SchemaDefinition/SchemaDefinition.php
@@ -78,7 +78,7 @@ public function resolveReference(
 
         while ($segment = array_shift($path)) {
             if (!isset($jsonSchema[$segment])) {
-                throw new SchemaException("Unresolved path segment: $segment");
+                throw new SchemaException("Unresolved path segment $segment in file {$this->source->getFile()}");
             }
 
             $jsonSchema = $jsonSchema[$segment];
diff --git a/src/Model/Validator/FilterValidator.php b/src/Model/Validator/FilterValidator.php
@@ -140,10 +140,11 @@ private function validateFilterCompatibilityWithBaseType(FilterInterface $filter
         ) {
             throw new SchemaException(
                 sprintf(
-                    'Filter %s is not compatible with property type %s for property %s',
+                    'Filter %s is not compatible with property type %s for property %s in file %s',
                     $filter->getToken(),
                     $property->getType(),
-                    $property->getName()
+                    $property->getName(),
+                    $property->getJsonSchema()->getFile()
                 )
             );
         }
@@ -174,10 +175,11 @@ private function validateFilterCompatibilityWithTransformedType(
         ) {
             throw new SchemaException(
                 sprintf(
-                    'Filter %s is not compatible with transformed property type %s for property %s',
+                    'Filter %s is not compatible with transformed property type %s for property %s in file %s',
                     $filter->getToken(),
                     $transformedType->getName(),
-                    $property->getName()
+                    $property->getName(),
+                    $property->getJsonSchema()->getFile()
                 )
             );
         }
diff --git a/src/PropertyProcessor/ComposedValue/IfProcessor.php b/src/PropertyProcessor/ComposedValue/IfProcessor.php
@@ -33,7 +33,13 @@ protected function generateValidators(PropertyInterface $property, JsonSchema $p
         $json = $propertySchema->getJson()['propertySchema']->getJson();
 
         if (!isset($json['then']) && !isset($json['else'])) {
-            throw new SchemaException('Incomplete conditional composition');
+            throw new SchemaException(
+                sprintf(
+                    'Incomplete conditional composition for property %s in file %s',
+                    $property->getName(),
+                    $property->getJsonSchema()->getFile()
+                )
+            );
         }
 
         $propertyFactory = new PropertyFactory(new PropertyProcessorFactory());
diff --git a/src/PropertyProcessor/Filter/FilterProcessor.php b/src/PropertyProcessor/Filter/FilterProcessor.php
@@ -59,7 +59,14 @@ public function process(
             }
 
             if (!($filter = $generatorConfiguration->getFilter($filterToken))) {
-                throw new SchemaException("Unsupported filter $filterToken");
+                throw new SchemaException(
+                    sprintf(
+                        'Unsupported filter %s on property %s in file %s',
+                        $filterToken,
+                        $property->getName(),
+                        $property->getJsonSchema()->getFile()
+                    )
+                );
             }
 
             $property->addValidator(
@@ -70,12 +77,20 @@ public function process(
             if ($filter instanceof TransformingFilterInterface) {
                 if ($property->getType() === 'array') {
                     throw new SchemaException(
-                        "Applying a transforming filter to the array property {$property->getName()} is not supported"
+                        sprintf(
+                            'Applying a transforming filter to the array property %s is not supported in file %s',
+                            $property->getName(),
+                            $property->getJsonSchema()->getFile()
+                        )
                     );
                 }
                 if ($transformingFilter) {
                     throw new SchemaException(
-                        "Applying multiple transforming filters for property {$property->getName()} is not supported"
+                        sprintf(
+                            'Applying multiple transforming filters for property %s is not supported in file %s',
+                            $property->getName(),
+                            $property->getJsonSchema()->getFile()
+                        )
                     );
                 }
 
diff --git a/src/PropertyProcessor/Property/AbstractTypedValueProcessor.php b/src/PropertyProcessor/Property/AbstractTypedValueProcessor.php
@@ -49,27 +49,34 @@ public function process(string $propertyName, JsonSchema $propertySchema): Prope
         $property = parent::process($propertyName, $propertySchema);
 
         if (isset($propertySchema->getJson()['default'])) {
-            $this->setDefaultValue($property, $propertySchema->getJson()['default']);
+            $this->setDefaultValue($property, $propertySchema->getJson()['default'], $propertySchema);
         }
 
         return $property;
     }
 
     /**
      * @param PropertyInterface $property
-     * @param                   $default
+     * @param mixed $default
+     * @param JsonSchema $propertySchema
      *
      * @throws SchemaException
      */
-    public function setDefaultValue(PropertyInterface $property, $default): void
+    public function setDefaultValue(PropertyInterface $property, $default, JsonSchema $propertySchema): void
     {
         // allow integer default values for Number properties
         if ($this instanceof NumberProcessor && is_int($default)) {
             $default = (float) $default;
         }
 
         if (!$this->getTypeCheckFunction()($default)) {
-            throw new SchemaException("Invalid type for default value of property {$property->getName()}");
+            throw new SchemaException(
+                sprintf(
+                    "Invalid type for default value of property %s in file %s",
+                    $property->getName(),
+                    $propertySchema->getFile()
+                )
+            );
         }
 
         $property->setDefaultValue($default);
diff --git a/src/PropertyProcessor/Property/BaseProcessor.php b/src/PropertyProcessor/Property/BaseProcessor.php
@@ -254,7 +254,13 @@ protected function transferComposedPropertiesToSchema(PropertyInterface $propert
 
             foreach ($validator->getComposedProperties() as $composedProperty) {
                 if (!$composedProperty->getNestedSchema()) {
-                    throw new SchemaException('No nested schema for composed property found');
+                    throw new SchemaException(
+                        sprintf(
+                            "No nested schema for composed property %s in file %s found",
+                            $property->getName(),
+                            $property->getJsonSchema()->getFile()
+                        )
+                    );
                 }
 
                 foreach ($composedProperty->getNestedSchema()->getProperties() as $property) {
diff --git a/src/PropertyProcessor/Property/BasereferenceProcessor.php b/src/PropertyProcessor/Property/BasereferenceProcessor.php
@@ -31,7 +31,11 @@ public function process(string $propertyName, JsonSchema $propertySchema): Prope
 
         if (!$property->getNestedSchema()) {
             throw new SchemaException(
-                "A referenced schema on base level must provide an object definition [$propertyName]"
+                sprintf(
+                    'A referenced schema on base level must provide an object definition for property %s in file %s',
+                    $propertyName,
+                    $propertySchema->getFile()
+                )
             );
         }
 
diff --git a/src/PropertyProcessor/Property/MultiTypeProcessor.php b/src/PropertyProcessor/Property/MultiTypeProcessor.php
@@ -169,7 +169,7 @@ protected function processSubProperties(
 
             if ($defaultValue !== null && $propertyProcessor instanceof AbstractTypedValueProcessor) {
                 try {
-                    $propertyProcessor->setDefaultValue($property, $defaultValue);
+                    $propertyProcessor->setDefaultValue($property, $defaultValue, $propertySchema);
                 } catch (SchemaException $e) {
                     $invalidDefaultValues++;
                     $invalidDefaultValueException = $e;
diff --git a/src/PropertyProcessor/Property/ObjectProcessor.php b/src/PropertyProcessor/Property/ObjectProcessor.php
@@ -44,7 +44,13 @@ public function process(string $propertyName, JsonSchema $propertySchema): Prope
         );
 
         if ($schema === null) {
-            throw new SchemaException("Failed to process schema for object property $propertyName");
+            throw new SchemaException(
+                sprintf(
+                    'Failed to process schema for object property %s in file %s',
+                    $propertyName,
+                    $propertySchema->getFile()
+                )
+            );
         }
 
         // if the generated schema is located in a different namespace (the schema for the given structure in
diff --git a/src/PropertyProcessor/Property/ReferenceProcessor.php b/src/PropertyProcessor/Property/ReferenceProcessor.php
@@ -43,9 +43,13 @@ public function process(string $propertyName, JsonSchema $propertySchema): Prope
                 return $definition->resolveReference($propertyName, $path, $this->propertyMetaDataCollection);
             }
         } catch (Exception $exception) {
-            throw new SchemaException("Unresolved Reference: $reference", 0, $exception);
+            throw new SchemaException(
+                "Unresolved Reference $reference in file {$propertySchema->getFile()}",
+                0,
+                $exception
+            );
         }
 
-        throw new SchemaException("Unresolved Reference: $reference");
+        throw new SchemaException("Unresolved Reference $reference in file {$propertySchema->getFile()}");
     }
 }
diff --git a/src/PropertyProcessor/Property/StringProcessor.php b/src/PropertyProcessor/Property/StringProcessor.php
@@ -107,7 +107,13 @@ protected function addLengthValidator(PropertyInterface $property, JsonSchema $p
     protected function addFormatValidator(PropertyInterface $property, JsonSchema $propertySchema): void
     {
         if (isset($propertySchema->getJson()['format'])) {
-            throw new SchemaException('Format is currently not supported');
+            throw new SchemaException(
+                sprintf(
+                    'Format is currently not supported for property %s in file %s',
+                    $property->getName(),
+                    $propertySchema->getFile()
+                )
+            );
         }
     }
 }
diff --git a/src/PropertyProcessor/PropertyProcessorFactory.php b/src/PropertyProcessor/PropertyProcessorFactory.php
@@ -42,7 +42,13 @@ public function getProcessor(
             return new MultiTypeProcessor($this, $type, $propertyMetaDataCollection, $schemaProcessor, $schema);
         }
 
-        throw new SchemaException('Invalid property type');
+        throw new SchemaException(
+            sprintf(
+                'Invalid property type %s in file %s',
+                $type,
+                $schema->getJsonSchema()->getFile()
+            )
+        );
     }
 
     /**
@@ -62,7 +68,13 @@ protected function getSingleTypePropertyProcessor(
     ): PropertyProcessorInterface {
         $processor = '\\PHPModelGenerator\\PropertyProcessor\\Property\\' . ucfirst(strtolower($type)) . 'Processor';
         if (!class_exists($processor)) {
-            throw new SchemaException("Unsupported property type $type");
+            throw new SchemaException(
+                sprintf(
+                    'Unsupported property type %s in file %s',
+                    $type,
+                    $schema->getJsonSchema()->getFile()
+                )
+            );
         }
 
         return new $processor($propertyMetaDataCollection, $schemaProcessor, $schema);
diff --git a/tests/Objects/ReferencePropertyTest.php b/tests/Objects/ReferencePropertyTest.php
@@ -31,7 +31,7 @@ class ReferencePropertyTest extends AbstractPHPModelGeneratorTest
     public function testNotResolvedReferenceThrowsAnException(string $reference): void
     {
         $this->expectException(SchemaException::class);
-        $this->expectExceptionMessage("Unresolved Reference: $reference");
+        $this->expectExceptionMessage("Unresolved Reference $reference in file");
 
         $this->generateClassFromFileTemplate('NotResolvedReference.json', [$reference]);
     }
diff --git a/tests/PropertyProcessor/PropertyProcessorFactoryTest.php b/tests/PropertyProcessor/PropertyProcessorFactoryTest.php
@@ -5,6 +5,7 @@
 use PHPModelGenerator\Exception\SchemaException;
 use PHPModelGenerator\Model\GeneratorConfiguration;
 use PHPModelGenerator\Model\Schema;
+use PHPModelGenerator\Model\SchemaDefinition\JsonSchema;
 use PHPModelGenerator\PropertyProcessor\Property\ArrayProcessor;
 use PHPModelGenerator\PropertyProcessor\Property\BooleanProcessor;
 use PHPModelGenerator\PropertyProcessor\Property\IntegerProcessor;
@@ -40,7 +41,7 @@ public function testGetPropertyProcessor(string $type, string $expectedClass): v
             $type,
             new PropertyMetaDataCollection(),
             new SchemaProcessor('', '', new GeneratorConfiguration(), new RenderQueue()),
-            new Schema('', '')
+            new Schema('', '', new JsonSchema('', []))
         );
 
         $this->assertInstanceOf($expectedClass, $propertyProcessor);
@@ -78,7 +79,7 @@ public function testGetInvalidPropertyProcessorThrowsAnException()
             'Hello',
             new PropertyMetaDataCollection(),
             new SchemaProcessor('', '', new GeneratorConfiguration(), new RenderQueue()),
-            new Schema('', '')
+            new Schema('', '', new JsonSchema('', []))
         );
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -78,7 +78,7 @@ public function resolveReference(`
`78`	`78`
`79`	`79`	`while ($segment = array_shift($path)) {`
`80`	`80`	`if (!isset($jsonSchema[$segment])) {`
`81`		`- throw new SchemaException("Unresolved path segment: $segment");`
	`81`	`+ throw new SchemaException("Unresolved path segment $segment in file {$this->source->getFile()}");`
`82`	`82`	`}`
`83`	`83`
`84`	`84`	`$jsonSchema = $jsonSchema[$segment];`
Original file line number	Diff line number	Diff line change
`@@ -49,27 +49,34 @@ public function process(string $propertyName, JsonSchema $propertySchema): Prope`
`49`	`49`	`$property = parent::process($propertyName, $propertySchema);`
`50`	`50`
`51`	`51`	`if (isset($propertySchema->getJson()['default'])) {`
`52`		`- $this->setDefaultValue($property, $propertySchema->getJson()['default']);`
	`52`	`+ $this->setDefaultValue($property, $propertySchema->getJson()['default'], $propertySchema);`
`53`	`53`	`}`
`54`	`54`
`55`	`55`	`return $property;`
`56`	`56`	`}`
`57`	`57`
`58`	`58`	`/**`
`59`	`59`	`* @param PropertyInterface $property`
`60`		`- * @param $default`
	`60`	`+ * @param mixed $default`
	`61`	`+ * @param JsonSchema $propertySchema`
`61`	`62`	`*`
`62`	`63`	`* @throws SchemaException`
`63`	`64`	`*/`
`64`		`- public function setDefaultValue(PropertyInterface $property, $default): void`
	`65`	`+ public function setDefaultValue(PropertyInterface $property, $default, JsonSchema $propertySchema): void`
`65`	`66`	`{`
`66`	`67`	`// allow integer default values for Number properties`
`67`	`68`	`if ($this instanceof NumberProcessor && is_int($default)) {`
`68`	`69`	`$default = (float) $default;`
`69`	`70`	`}`
`70`	`71`
`71`	`72`	`if (!$this->getTypeCheckFunction()($default)) {`
`72`		`- throw new SchemaException("Invalid type for default value of property {$property->getName()}");`
	`73`	`+ throw new SchemaException(`
	`74`	`+ sprintf(`
	`75`	`+ "Invalid type for default value of property %s in file %s",`
	`76`	`+ $property->getName(),`
	`77`	`+ $propertySchema->getFile()`
	`78`	`+ )`
	`79`	`+ );`
`73`	`80`	`}`
`74`	`81`
`75`	`82`	`$property->setDefaultValue($default);`