Fixed Compiler

Changed not-nullable syntax to nullable

Author: ProgMiner

app/Compiler.php

@@ -138,6 +138,8 @@ protected function compileClass(ClassModel $classModel, FileModel $fileModel): s
                 }
 
                 $result .= "return \$value;\n}\n";
+            } else {
+                $result .= "protected function validate_{$fieldModel->name}(\$value) { return \$value; }\n";
             }
 
             if ($fieldModel->editable) {

app/Model/ClassModel.pdata

@@ -24,10 +24,10 @@ namespace PHPDataGen\Model;
 
 class ClassModel {
 
-    val name: string!;
+    val name: string;
 
-    val extends: string;
-    var implements: array!;
+    val extends: string?;
+    var implements: array;
 
-    var fields: array!;
+    var fields: array;
 }

app/Model/FieldModel.pdata

@@ -26,14 +26,14 @@ use PHPDataGen\Type;
 
 class FieldModel {
 
-    val name: string!;
+    val name: string;
 
-    val editable: bool! = false;
-    val direct:   bool! = false;
+    val editable: bool = false;
+    val direct:   bool = false;
 
-    val type:       Type!;
-    val validators: array!;
+    val type:       Type;
+    val validators: array;
 
-    val filterDefault: bool! = true;
-    val default:       string;
+    val filterDefault: bool = true;
+    val default:       string?;
 }

app/Model/FileModel.pdata

@@ -24,8 +24,8 @@ namespace PHPDataGen\Model;
 
 class FileModel {
 
-    val namespace: string;
+    val namespace: string?;
 
-    val uses: array!;
-    var classes: array!;
+    val uses: array;
+    var classes: array;
 }

app/Parsing/Conveyor.php

@@ -225,7 +225,7 @@ public function readExtendedClassname(): string {
      * @return Type Type
      */
     public function readType(): Type {
-        return new Type($this->readExtendedClassname(), !$this->readOperator('!'));
+        return new Type($this->readExtendedClassname(), $this->readOperator('?'));
     }
 
     /**

app/Type.pdata

@@ -24,9 +24,9 @@ namespace PHPDataGen;
 
 class Type {
 
-    direct val name: string!;
+    direct val name: string;
 
-    val nullable: bool!;
-    val mixed:    bool!;
-    val class:    bool!;
+    val nullable: bool;
+    val mixed:    bool;
+    val class:    bool;
 }

app/Type.php

@@ -36,7 +36,7 @@ class Type extends Data_Type {
     /**
      * @param string $type Type name of class
      */
-    public function __construct(string $type, bool $nullable = true) {
+    public function __construct(string $type, bool $nullable = false) {
         $fields = [
             'name'     => $type,
 

tests/Data_Test.php

@@ -2,29 +2,29 @@
 class Data_Test {
 use \PHPDataGen\DataClassTrait;
 private $A = null;
-private $A1 = null;
+private $A1 = '';
 private $A2 = null;
 private $A3 = null;
-private $A4 = null;
-private $A5 = null;
+private $A4 = '';
+private $A5 = '';
 private $B = null;
-private $B1 = null;
+private $B1 = '';
 private $B2 = null;
 private $B3 = null;
-private $B4 = null;
-private $B5 = null;
+private $B4 = '';
+private $B5 = '';
 protected $C = null;
-protected $C1 = null;
+protected $C1 = '';
 protected $C2 = null;
 protected $C3 = null;
-protected $C4 = null;
-protected $C5 = null;
+protected $C4 = '';
+protected $C5 = '';
 protected $D = null;
-protected $D1 = null;
+protected $D1 = '';
 protected $D2 = null;
 protected $D3 = null;
-protected $D4 = null;
-protected $D5 = null;
+protected $D4 = '';
+protected $D5 = '';
 public function __construct(array $init = []) {
 $this->A2 = $this->validate_A2("Foo");
 $this->A3 = "Fee";
@@ -48,86 +48,98 @@ public function __construct(array $init = []) {
 }
 }
 public function get_A() { return $this->A; }
+protected function validate_A($value) { return $value; }
 public function get_A1() { return $this->A1; }
 protected function validate_A1($value) {
-if (!is_null($value) && !is_string($value)) { throw new \InvalidArgumentException('Field A1 has type string'); }
+if (!is_string($value)) { throw new \InvalidArgumentException('Field A1 has type string'); }
 return $value;
 }
 public function get_A2() { return $this->A2; }
+protected function validate_A2($value) { return $value; }
 public function get_A3() { return $this->A3; }
+protected function validate_A3($value) { return $value; }
 public function get_A4() { return $this->A4; }
 protected function validate_A4($value) {
-if (!is_null($value) && !is_string($value)) { throw new \InvalidArgumentException('Field A4 has type string'); }
+if (!is_string($value)) { throw new \InvalidArgumentException('Field A4 has type string'); }
 return $value;
 }
 public function get_A5() { return $this->A5; }
 protected function validate_A5($value) {
-if (!is_null($value) && !is_string($value)) { throw new \InvalidArgumentException('Field A5 has type string'); }
+if (!is_string($value)) { throw new \InvalidArgumentException('Field A5 has type string'); }
 return $value;
 }
 public function &get_B() { return $this->B; }
+protected function validate_B($value) { return $value; }
 public function set_B($value) { $this->B = $this->validate_B($value);}
 public function &get_B1() { return $this->B1; }
 protected function validate_B1($value) {
-if (!is_null($value) && !is_string($value)) { throw new \InvalidArgumentException('Field B1 has type string'); }
+if (!is_string($value)) { throw new \InvalidArgumentException('Field B1 has type string'); }
 return $value;
 }
 public function set_B1($value) { $this->B1 = $this->validate_B1($value);}
 public function &get_B2() { return $this->B2; }
+protected function validate_B2($value) { return $value; }
 public function set_B2($value) { $this->B2 = $this->validate_B2($value);}
 public function &get_B3() { return $this->B3; }
+protected function validate_B3($value) { return $value; }
 public function set_B3($value) { $this->B3 = $this->validate_B3($value);}
 public function &get_B4() { return $this->B4; }
 protected function validate_B4($value) {
-if (!is_null($value) && !is_string($value)) { throw new \InvalidArgumentException('Field B4 has type string'); }
+if (!is_string($value)) { throw new \InvalidArgumentException('Field B4 has type string'); }
 return $value;
 }
 public function set_B4($value) { $this->B4 = $this->validate_B4($value);}
 public function &get_B5() { return $this->B5; }
 protected function validate_B5($value) {
-if (!is_null($value) && !is_string($value)) { throw new \InvalidArgumentException('Field B5 has type string'); }
+if (!is_string($value)) { throw new \InvalidArgumentException('Field B5 has type string'); }
 return $value;
 }
 public function set_B5($value) { $this->B5 = $this->validate_B5($value);}
 public function get_C() { return $this->C; }
+protected function validate_C($value) { return $value; }
 public function get_C1() { return $this->C1; }
 protected function validate_C1($value) {
-if (!is_null($value) && !is_string($value)) { throw new \InvalidArgumentException('Field C1 has type string'); }
+if (!is_string($value)) { throw new \InvalidArgumentException('Field C1 has type string'); }
 return $value;
 }
 public function get_C2() { return $this->C2; }
+protected function validate_C2($value) { return $value; }
 public function get_C3() { return $this->C3; }
+protected function validate_C3($value) { return $value; }
 public function get_C4() { return $this->C4; }
 protected function validate_C4($value) {
-if (!is_null($value) && !is_string($value)) { throw new \InvalidArgumentException('Field C4 has type string'); }
+if (!is_string($value)) { throw new \InvalidArgumentException('Field C4 has type string'); }
 return $value;
 }
 public function get_C5() { return $this->C5; }
 protected function validate_C5($value) {
-if (!is_null($value) && !is_string($value)) { throw new \InvalidArgumentException('Field C5 has type string'); }
+if (!is_string($value)) { throw new \InvalidArgumentException('Field C5 has type string'); }
 return $value;
 }
 public function &get_D() { return $this->D; }
+protected function validate_D($value) { return $value; }
 public function set_D($value) { $this->D = $this->validate_D($value);}
 public function &get_D1() { return $this->D1; }
 protected function validate_D1($value) {
-if (!is_null($value) && !is_string($value)) { throw new \InvalidArgumentException('Field D1 has type string'); }
+if (!is_string($value)) { throw new \InvalidArgumentException('Field D1 has type string'); }
 return $value;
 }
 public function set_D1($value) { $this->D1 = $this->validate_D1($value);}
 public function &get_D2() { return $this->D2; }
+protected function validate_D2($value) { return $value; }
 public function set_D2($value) { $this->D2 = $this->validate_D2($value);}
 public function &get_D3() { return $this->D3; }
+protected function validate_D3($value) { return $value; }
 public function set_D3($value) { $this->D3 = $this->validate_D3($value);}
 public function &get_D4() { return $this->D4; }
 protected function validate_D4($value) {
-if (!is_null($value) && !is_string($value)) { throw new \InvalidArgumentException('Field D4 has type string'); }
+if (!is_string($value)) { throw new \InvalidArgumentException('Field D4 has type string'); }
 return $value;
 }
 public function set_D4($value) { $this->D4 = $this->validate_D4($value);}
 public function &get_D5() { return $this->D5; }
 protected function validate_D5($value) {
-if (!is_null($value) && !is_string($value)) { throw new \InvalidArgumentException('Field D5 has type string'); }
+if (!is_string($value)) { throw new \InvalidArgumentException('Field D5 has type string'); }
 return $value;
 }
 public function set_D5($value) { $this->D5 = $this->validate_D5($value);}