updated for php 7.1

phpstan.neon

@@ -1,4 +1,5 @@
 parameters:
-    level: 1
+    level: max
     paths:
         - src/
+        - tests/

src/Sloth/LazyAccessor.php

@@ -1,56 +1,78 @@
 <?php
 
+declare(strict_types=1);
+
 namespace Sloth;
 
-class LazyAccessor
+/**
+ * @template T
+ */
+final class LazyAccessor
 {
-    /** @var callable */
+    /** @var callable(): object */
     private $callback;
 
+    /** @var ?object */
     private $object;
 
-    public function __construct($callback)
+    /**
+     * @param callable(): object $callback
+     */
+    public function __construct(callable $callback)
     {
-        if (!is_callable($callback)) {
-            throw new InvalidArgumentException();
-        }
         $this->callback = $callback;
     }
 
-    public function __get($name)
+    /**
+     * @return mixed
+     */
+    public function __get(string $name)
     {
-        $this->initialize();
-        return $this->object->$name;
+        return $this->getObject()->$name;
     }
 
-    public function __set($name, $value)
+    /**
+     * @param mixed $value
+     */
+    public function __set(string $name, $value): void
     {
-        $this->initialize();
-        return $this->object->$name = $value;
+        $this->getObject()->$name = $value;
     }
 
-    public function __isset($name)
+    public function __isset(string $name): bool
     {
-        $this->initialize();
-        return isset($this->object->$name);
+        return isset($this->getObject()->$name);
     }
 
-    public function __unset($name)
+    public function __unset(string $name): void
     {
-        $this->initialize();
-        unset($this->object->$name);
+        unset($this->getObject()->$name);
     }
 
-    public function __call($name, array $arguments)
+    /**
+     * @param mixed[] $arguments
+     * @return mixed
+     */
+    public function __call(string $name, array $arguments)
     {
-        $this->initialize();
-        return call_user_func_array(array($this->object, $name), $arguments);
+        $callable = [$this->getObject(), $name];
+
+        if (!is_callable($callable)) {
+            throw new \TypeError(sprintf('class \'%s\' does not have method \'%s\'', static::class, $name));
+        }
+
+        return call_user_func_array($callable, $arguments);
     }
 
-    private function initialize()
+    /**
+     * @return object
+     */
+    private function getObject()
     {
         if ($this->object === null) {
             $this->object = call_user_func($this->callback);
         }
+
+        return $this->object;
     }
 }

src/Sloth/LazyIterator.php

@@ -1,44 +1,50 @@
 <?php
 
+declare(strict_types=1);
+
 namespace Sloth;
 
-class LazyIterator implements \IteratorAggregate, \Countable
+/**
+ * @template TKey
+ * @template TValue
+ * @implements \IteratorAggregate<TKey, TValue>
+ */
+final class LazyIterator implements \IteratorAggregate, \Countable
 {
-    /** @var callable */
+    /** @var callable(): iterable<TKey, TValue> */
     private $callback;
 
-    /** @var \Iterator */
+    /** @var ?iterable<TKey, TValue> */
     private $iterator;
 
     /**
-     * @param $callback that returns \Traversable, \Iterator or array
+     * @param callable(): iterable<TKey, TValue> $callback
      */
-    public function __construct($callback)
+    public function __construct(callable $callback)
     {
-        if (!is_callable($callback)) {
-            throw new InvalidArgumentException();
-        }
         $this->callback = $callback;
     }
 
     /**
-     * @return \Traversable iterator
+     * @return iterable<TKey, TValue>
      */
-    public function getIterator()
+    public function getIterator(): iterable
     {
         if ($this->iterator !== null) {
             return $this->iterator;
         }
+
         $iterator = call_user_func($this->callback);
+
         if (is_array($iterator)) {
             $this->iterator = new \ArrayIterator($iterator);
             return $this->iterator;
         }
-        $this->iterator = $iterator;
-        return $this->iterator;
+
+        return $this->iterator = $iterator;
     }
 
-    public function count()
+    public function count(): int
     {
         return iterator_count($this);
     }

src/Sloth/LazyString.php

@@ -1,32 +1,33 @@
 <?php
 
+declare(strict_types=1);
+
 namespace Sloth;
 
-class LazyString
+final class LazyString
 {
-    /** @var callable */
+    /** @var callable(): string */
     private $callback;
 
-    /** @var string */
+    /** @var ?string */
     private $string;
 
     /**
-     * @param $callback that returns \Traversable, \Iterator or array
+     * @param callable(): string $callback
      */
-    public function __construct($callback)
+    public function __construct(callable $callback)
     {
-        if (!is_callable($callback)) {
-            throw new InvalidArgumentException();
-        }
         $this->callback = $callback;
     }
 
-    public function __toString()
+    public function __toString(): string
     {
         if ($this->string !== null) {
             return $this->string;
         }
+
         $this->string = call_user_func($this->callback);
+
         return $this->string;
     }
 }

tests/LazyAccessor.checksCallable.phpt

@@ -2,6 +2,6 @@
 
 require __DIR__ . '/bootstrap.php';
 
-Assert::exception(function () {
+Assert::throws(function () {
     new Sloth\LazyAccessor('not callable');
-}, 'Sloth\InvalidArgumentException');
+}, TypeError::class);

tests/LazyAccessor.methodCall.phpt

@@ -14,4 +14,8 @@ $greeter = new \Sloth\LazyAccessor($callback);
 \Assert::equal('Hello world!', $greeter->sayHello('world'));
 \Assert::equal('Hello John!', $greeter->sayHello('John'));
 
+\Assert::throws(function () use ($greeter) {
+    $greeter->nonExistingMethod();
+}, TypeError::class);
+
 \Assert::equal(1, $countCalled);

tests/LazyIterator.arrayIterator.phpt

@@ -3,11 +3,11 @@
 require __DIR__ . '/bootstrap.php';
 
 $callback = function () {
-    return new ArrayIterator(array(1, 2, 3));
+    return new ArrayIterator([1, 2, 3]);
 };
 $iterator = new Sloth\LazyIterator($callback);
 
-$values = array();
+$values = [];
 foreach ($iterator as $value) {
     $values[] = $value;
 }
@@ -19,7 +19,7 @@ Assert::equal(3, $values[2]);
 
 
 $callback = function () {
-    return new ArrayIterator(array());
+    return new ArrayIterator([]);
 };
 $iterator = new Sloth\LazyIterator($callback);
 $values = iterator_to_array($iterator);

tests/LazyIterator.callbackIsCalledOnlyOnce.phpt

@@ -5,7 +5,7 @@ require __DIR__ . '/bootstrap.php';
 $countCalled = 0;
 $callback = function () use (&$countCalled) {
     $countCalled++;
-    return new ArrayIterator(array());
+    return new ArrayIterator([]);
 };
 $iterator = new Sloth\LazyIterator($callback);
 

tests/LazyIterator.checksCallable.phpt

@@ -2,6 +2,6 @@
 
 require __DIR__ . '/bootstrap.php';
 
-Assert::exception(function () {
+Assert::throws(function () {
     new Sloth\LazyIterator('not callable');
-}, 'Sloth\InvalidArgumentException');
+}, TypeError::class);

tests/LazyIterator.implementsCountable.phpt

@@ -3,7 +3,7 @@
 require __DIR__ . '/bootstrap.php';
 
 $iterator = new Sloth\LazyIterator(function () {
-    return new ArrayIterator(array('a', 'b', 'c'));
+    return new ArrayIterator(['a', 'b', 'c']);
 });
 
 Assert::equal(3, count($iterator));

tests/LazyIterator.retypesArrayToIterator.phpt

@@ -3,7 +3,7 @@
 require __DIR__ . '/bootstrap.php';
 
 $iterator = new Sloth\LazyIterator(function () {
-    return array(1 => 'a', 3 => 'b');
+    return [1 => 'a', 3 => 'b'];
 });
 
 Assert::true($iterator->getIterator() instanceof Iterator);

tests/LazyString.checksCallable.phpt

@@ -2,6 +2,6 @@
 
 require __DIR__ . '/bootstrap.php';
 
-Assert::exception(function () {
+Assert::throws(function () {
     new Sloth\LazyString('not callable');
-}, 'Sloth\InvalidArgumentException');
+}, TypeError::class);

tests/Mocks/Greeter.php

@@ -1,10 +1,12 @@
 <?php
 
+declare(strict_types=1);
+
 namespace SlothTests\Mocks;
 
 class Greeter
 {
-    public function sayHello($name)
+    public function sayHello(string $name): string
     {
         return "Hello $name!";
     }

tests/Mocks/Person.php

@@ -4,9 +4,10 @@
 
 class Person
 {
+    /** @var string */
     public $name;
 
-    public function __construct($name)
+    public function __construct(string $name)
     {
         $this->name = $name;
     }