FIX: non built type with default value

README.md

@@ -178,7 +178,7 @@ $container->set(FooBar::class, function () {
 $container->get(Test::class); // FooBar it will inject into Test class.  
 ```
 
-**Note:** We only support resolving auto wiring argument on construction if they is binded into container. Otherwise it will throw an exception.  
+**Note:** We only support resolving auto wiring argument on construction if they is binded into container. Otherwise it will throw an exception if can't find entry into container.
 
 ### Using Built in type  
 
@@ -221,6 +221,30 @@ $container = new Container();
 $container->get(Test::class); // null it will inject into Test class.  
 ```  
 
+In also attempt to resolve auto wiring of construction by it's default value, it will check default value of `__construction` and it will pass that default value.   
+
+First case, if value is a simple built in type value.  
+```php
+use Gravatalonga\Container\Container;
+
+class Test
+{
+    /**
+     * @var string
+     */
+    private $name;
+
+    public function __construct($name = 'Jonathan Fontes')
+    {
+        $this->name = $name;
+    }
+}
+
+$container = new Container(); 
+
+$container->get(Test::class); // 'Jonathan Fontes' it will pass into container...
+```  
+
 ## Change log
 
 Please see [CHANGELOG](CHANGELOG.md) for more information on what has changed recently.

src/Container.php

@@ -124,8 +124,8 @@ public static function getInstance()
     public function has($id)
     {
         return array_key_exists($id, $this->bindings) ||
-                array_key_exists($id, $this->share) ||
-                array_key_exists($id, $this->aliases);
+            array_key_exists($id, $this->share) ||
+            array_key_exists($id, $this->aliases);
     }
 
     /**
@@ -253,7 +253,11 @@ function (ReflectionParameter $param) use ($arguments) {
                         return $this->get($param->getName());
                     }
 
-                    throw ContainerException::findType(null);
+                    if (false === $param->isOptional()) {
+                        throw ContainerException::findType(null);
+                    }
+
+                    return $param->getDefaultValue();
                 }
 
                 if (true === $type->isBuiltin()) {

tests/ResolveConstructionTest.php

@@ -14,6 +14,8 @@
 use Tests\Stub\FooBarClass;
 use Tests\Stub\FooBarWithNullClass;
 use Tests\Stub\FooBarWithoutBuiltInTypeClass;
+use Tests\Stub\FooBarWithoutBuiltInTypeNullableClass;
+use Tests\Stub\FooBarWithoutBuiltInTypeStringDefaultValue;
 use Tests\Stub\FooInterface;
 
 /**
@@ -102,15 +104,58 @@ public function testGotExceptionFromVariableNameAndBuiltTypeNotIntoContainer()
         $this->expectException(ContainerException::class);
         $this->expectExceptionMessage('Unable to find type hint (string)');
         $container = new Container();
-        $class = $container->get(FooBarClass::class);
+        $container->get(FooBarClass::class);
     }
 
     public function testGotExceptionFromVariableNameNotIntoContainer()
     {
         $this->expectException(ContainerException::class);
         $this->expectExceptionMessage('Unable to find type hint ()');
         $container = new Container();
-        $class = $container->get(FooBarWithoutBuiltInTypeClass::class);
+        $container->get(FooBarWithoutBuiltInTypeClass::class);
+    }
+
+    /**
+     * @test
+     */
+    public function testCanResolveClassIfConstructorAcceptNullable()
+    {
+        // FooBarWithoutBuiltInTypeNullableClass
+        $container = new Container();
+
+        $class = $container->get(FooBarWithoutBuiltInTypeNullableClass::class);
+
+        self::assertInstanceOf(FooBarWithoutBuiltInTypeNullableClass::class, $class);
+        self::assertNull($class->name);
+    }
+
+    /**
+     * @test
+     */
+    public function testCanPassOtherDefaultValueToConstructionsIfNotIsNullable()
+    {
+        $container = new Container();
+        $class = $container->get(FooBarWithoutBuiltInTypeStringDefaultValue::class);
+
+        self::assertInstanceOf(FooBarWithoutBuiltInTypeStringDefaultValue::class, $class);
+        self::assertNotNull($class->name);
+        self::assertEquals('hello world', $class->name);
+    }
+
+    /**
+     * @test
+     */
+    public function canPassOtherDefaultValueToConstructions()
+    {
+        $container = new Container();
+        $container->set('name', function () {
+            return 'Jonathan Fontes';
+        });
+        $class2 = $container->get(FooBarWithoutBuiltInTypeStringDefaultValue::class);
+
+        self::assertInstanceOf(FooBarWithoutBuiltInTypeStringDefaultValue::class, $class2);
+        self::assertNotNull($class2->name);
+        self::assertEquals('Jonathan Fontes', $class2->name);
     }
 
     public function testIfParamIsNullableButWeHaveValueFromContainer()

tests/Stub/FooBarWithoutBuiltInTypeNullableClass.php

@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Tests\Stub;
+
+class FooBarWithoutBuiltInTypeNullableClass
+{
+    public $name;
+
+    public function __construct($name = null)
+    {
+        $this->name = $name;
+    }
+}

tests/Stub/FooBarWithoutBuiltInTypeStringDefaultValue.php

@@ -0,0 +1,16 @@
+<?php
+
+namespace Tests\Stub;
+
+class FooBarWithoutBuiltInTypeStringDefaultValue
+{
+    /**
+     * @var string
+     */
+    public $name;
+
+    public function __construct($name = 'hello world')
+    {
+        $this->name = $name;
+    }
+}