Write types implementation

Author: Christian Blank

README.md

@@ -19,16 +19,10 @@ Create a requirement:
 $requirement = new ListType(
     new ObjectType([
         'foo' => new StringType(),
-        'bar' => new StringType()
-    ]),
-    new ObjectType([
-        'foo' => new StringType(),
-        'bar' => new IntType()
-    ]),
-    new ObjectType([
-        'foo' => new AnyType(),
-        'bar' => new IntType()
-    ]),
+        'bar' => new IntType(),
+        'buzz' => new AnyType(),
+        'foobar' => new NullableType(new StringType())
+    ])
 );
 ```
 Have some sort of external data you want to check.
@@ -37,12 +31,17 @@ $data = [
     [
         'foo' => 'foe',
         'bar' => 'baz',
+        'buzz' => 'foe',
+        'foobar' => null
     ], [
         'foo' => 'foe',
         'bar' => 7,
+        'buzz' => 'foe',
+        'foobar' => 'baz',
     ], [
         'foo' => [],
-        'bar' => 'baz',
+        'bar' => 9.1,
+        'foobar' => 'baz',
     ],
 ];
 ```

spec/Type/AnyTypeSpec.php

@@ -0,0 +1,15 @@
+<?php
+
+namespace spec\StructureCheck\Type;
+
+use StructureCheck\Type\AnyType;
+use PhpSpec\ObjectBehavior;
+use Prophecy\Argument;
+
+class AnyTypeSpec extends ObjectBehavior
+{
+    function it_is_initializable()
+    {
+        $this->shouldHaveType(AnyType::class);
+    }
+}

spec/Type/ListTypeSpec.php

@@ -5,11 +5,13 @@
 use StructureCheck\Type\ListType;
 use PhpSpec\ObjectBehavior;
 use Prophecy\Argument;
+use StructureCheck\Type\TypeInterface;
 
 class ListTypeSpec extends ObjectBehavior
 {
-    function it_is_initializable()
+    function it_is_initializable(TypeInterface $childType)
     {
+        $this->beConstructedWith($childType);
         $this->shouldHaveType(ListType::class);
     }
 }

spec/Type/ObjectTypeSpec.php

@@ -5,11 +5,13 @@
 use StructureCheck\Type\ObjectType;
 use PhpSpec\ObjectBehavior;
 use Prophecy\Argument;
+use StructureCheck\Type\TypeInterface;
 
 class ObjectTypeSpec extends ObjectBehavior
 {
-    function it_is_initializable()
+    function it_is_initializable(TypeInterface $childType)
     {
+        $this->beConstructedWith([$childType]);
         $this->shouldHaveType(ObjectType::class);
     }
 }

src/Type/AnyType.php

@@ -0,0 +1,7 @@
+<?php
+
+namespace StructureCheck\Type;
+
+class AnyType
+{
+}

src/Type/FloatType.php

@@ -2,6 +2,22 @@
 
 namespace StructureCheck\Type;
 
-class FloatType
+class FloatType implements TypeInterface
 {
-}
+    private static $errorMessage = 'The value %s is not a float.';
+
+    /**
+     * @param mixed $value
+     *
+     * @return ResultInterface
+     */
+    public function check($value)
+    {
+        $checkResult = is_float($value);
+
+        return new Result(
+            $checkResult,
+            !$checkResult ? [sprintf(self::$errorMessage, json_encode($value))] : []
+        );
+    }
+}

src/Type/ListType.php

@@ -2,6 +2,53 @@
 
 namespace StructureCheck\Type;
 
-class ListType
+use StructureCheck\Result;
+
+/**
+ * Class ListType
+ * @package StructureCheck\Type
+ */
+class ListType implements TypeInterface
 {
+    private static $isNotAnArrayMessage = 'The given value %s is not an array.';
+
+    /**
+     * @var TypeInterface[]
+     */
+    private $child;
+
+    /**
+     * ListType constructor.
+     *
+     * @param TypeInterface $child
+     */
+    public function __construct(TypeInterface $child)
+    {
+        $this->child = $child;
+    }
+
+    /**
+     * @inheritdoc
+     */
+    public function check($value)
+    {
+        if (!is_array($value)) {
+            return new Result(
+                false,
+                [sprintf(self::$isNotAnArrayMessage, json_encode($value))]
+            );
+        }
+
+        $errors = [];
+        $valid = true;
+
+        foreach ($value as $item) {
+            $result = $this->child->check($item);
+
+            $valid &= $result->isValid();
+            $errors += $result->getErrors();
+        }
+
+        return new Result($valid, $errors);
+    }
 }

src/Type/ObjectType.php

@@ -2,6 +2,48 @@
 
 namespace StructureCheck\Type;
 
-class ObjectType
+use StructureCheck\Result;
+
+class ObjectType implements TypeInterface
 {
+    private static $missingKeyErrorMessage = 'The key "%s" does not exists';
+
+    /**
+     * @var TypeInterface[]
+     */
+    private $children;
+
+    /**
+     * ObjectType constructor.
+     *
+     * @param TypeInterface[] $children
+     */
+    public function __construct(array $children)
+    {
+        $this->children = $children;
+    }
+
+    /**
+     * @inheritdoc
+     */
+    public function check($value)
+    {
+        $errors = [];
+        $valid = true;
+
+        foreach ($this->children as $key => $child) {
+            if (!array_key_exists($key, $value)) {
+                $valid = false;
+                $errors[] = sprintf(self::$missingKeyErrorMessage, $key);
+
+                continue;
+            }
+
+            $result = $child->check($value[$key]);
+            $valid &= $result->isValid();
+            $errors += $result->getErrors();
+        }
+
+        return new Result($valid, $errors);
+    }
 }