Merge pull request #3 from mister-spock/feature/add-to-string-method

Update PHPUnit, add '__toString()' method implementation, add tests
centraldesktop · Jan 19, 2021 · a94188b · a94188b
2 parents eeb6027 + 755c73a
commit a94188b
Show file tree

Hide file tree

Showing 10 changed files with 122 additions and 68 deletions.
diff --git a/.travis.yml b/.travis.yml
@@ -1,11 +1,11 @@
 language: php
 php:
   - 5.6
-  - 7.0
+  - 7.4
 
 before_script:
   - wget http://getcomposer.org/composer.phar
-  - php composer.phar install --dev
+  - php composer.phar install
 
 script:
   - phpunit

diff --git a/src/PhpOption/LazyOption.php b/src/PhpOption/LazyOption.php
@@ -161,14 +161,19 @@ public function foldRight($initialValue, $callable)
         return $this->option()->foldRight($initialValue, $callable);
     }
 
+    public function __toString()
+    {
+        return is_null($this->option) ? 'LazyOption(...not evaluated...)' : "LazyOption({$this->option})";
+    }
+
     /**
      * @return Option
      */
     private function option()
     {
         if (null === $this->option) {
             $this->option = call_user_func_array($this->callback, $this->arguments);
-            if (!$this->option instanceof Option) {
+            if (!($this->option instanceof Option)) {
                 $this->option = null;
                 throw new \RuntimeException('Expected instance of \PhpOption\Option');
             }

diff --git a/src/PhpOption/None.php b/src/PhpOption/None.php
@@ -136,5 +136,9 @@ public function foldRight($initialValue, $callable)
         return $initialValue;
     }
 
+    public function __toString() {
+        return "None()";
+    }
+
     private function __construct() { }
 }
diff --git a/src/PhpOption/Option.php b/src/PhpOption/Option.php
@@ -380,4 +380,10 @@ abstract public function foldLeft($initialValue, $callable);
      * @return mixed
      */
     abstract public function foldRight($initialValue, $callable);
+
+    /**
+     * String representation of the value.
+     * @return string
+     */
+    abstract public function __toString();
 }
diff --git a/src/PhpOption/Some.php b/src/PhpOption/Some.php
@@ -179,4 +179,14 @@ public function foldRight($initialValue, $callable)
     {
         return call_user_func($callable, $this->value, $initialValue);
     }
+
+    public function __toString()
+    {
+        if (!is_object($this->value)) {
+            return "Some($this->value)";
+        }
+
+        $object_class = get_class($this->value);
+        return method_exists($this->value, '__toString') ? "Some({$this->value})" : "Some($object_class(...))";
+    }
 }
diff --git a/tests/PhpOption/Tests/LazyOptionTest.php b/tests/PhpOption/Tests/LazyOptionTest.php
@@ -2,11 +2,14 @@
 
 namespace PhpOption\Tests;
 
-use stdClass;
 use ArrayIterator;
-use PhpOption\Some;
-use PhpOption\None;
+use InvalidArgumentException;
 use PhpOption\LazyOption;
+use PhpOption\None;
+use PhpOption\Option;
+use PhpOption\Some;
+use RuntimeException;
+use stdClass;
 
 class LazyOptionTest extends \PHPUnit_Framework_TestCase
 {
@@ -33,7 +36,7 @@ public function testGetWithArgumentsAndConstructor()
         $this->assertEquals('foo', $some->get());
         $this->assertEquals('foo', $some->getOrElse(null));
         $this->assertEquals('foo', $some->getOrCall('does_not_exist'));
-        $this->assertEquals('foo', $some->getOrThrow(new \RuntimeException('does_not_exist')));
+        $this->assertEquals('foo', $some->getOrThrow(new RuntimeException('does_not_exist')));
         $this->assertFalse($some->isEmpty());
     }
 
@@ -50,7 +53,7 @@ public function testGetWithArgumentsAndCreate()
         $this->assertEquals('foo', $some->get());
         $this->assertEquals('foo', $some->getOrElse(null));
         $this->assertEquals('foo', $some->getOrCall('does_not_exist'));
-        $this->assertEquals('foo', $some->getOrThrow(new \RuntimeException('does_not_exist')));
+        $this->assertEquals('foo', $some->getOrThrow(new RuntimeException('does_not_exist')));
         $this->assertFalse($some->isEmpty());
     }
 
@@ -66,7 +69,7 @@ public function testGetWithoutArgumentsAndConstructor()
         $this->assertEquals('foo', $some->get());
         $this->assertEquals('foo', $some->getOrElse(null));
         $this->assertEquals('foo', $some->getOrCall('does_not_exist'));
-        $this->assertEquals('foo', $some->getOrThrow(new \RuntimeException('does_not_exist')));
+        $this->assertEquals('foo', $some->getOrThrow(new RuntimeException('does_not_exist')));
         $this->assertFalse($some->isEmpty());
     }
 
@@ -84,13 +87,9 @@ public function testGetWithoutArgumentsAndCreate()
         $this->assertEquals('foo', $option->get());
         $this->assertEquals('foo', $option->getOrElse(null));
         $this->assertEquals('foo', $option->getOrCall('does_not_exist'));
-        $this->assertEquals('foo', $option->getOrThrow(new \RuntimeException('does_not_exist')));
+        $this->assertEquals('foo', $option->getOrThrow(new RuntimeException('does_not_exist')));
     }
 
-    /**
-     * @expectedException \RuntimeException
-     * @expectedExceptionMessage None has no value
-     */
     public function testCallbackReturnsNull()
     {
         $option = LazyOption::create(array($this->subject, 'execute'));
@@ -105,13 +104,12 @@ public function testCallbackReturnsNull()
         $this->assertEquals('alt', $option->getOrElse('alt'));
         $this->assertEquals('alt', $option->getOrCall(function(){return 'alt';}));
 
+        $this->expectException(RuntimeException::class);
+        $this->expectExceptionMessage("None has no value");
+
         $option->get();
     }
 
-    /**
-     * @expectedException \RuntimeException
-     * @expectedExceptionMessage Expected instance of \PhpOption\Option
-     */
     public function testExceptionIsThrownIfCallbackReturnsNonOption()
     {
         $option = LazyOption::create(array($this->subject, 'execute'));
@@ -121,24 +119,23 @@ public function testExceptionIsThrownIfCallbackReturnsNonOption()
             ->method('execute')
             ->will($this->returnValue(null));
 
+        $this->expectException(RuntimeException::class);
+        $this->expectExceptionMessage("Expected instance of \PhpOption\Option");
+
         $this->assertFalse($option->isDefined());
     }
 
-    /**
-     * @expectedException \InvalidArgumentException
-     * @expectedExceptionMessage Invalid callback given
-     */
     public function testInvalidCallbackAndConstructor()
     {
+        $this->expectException(InvalidArgumentException::class);
+        $this->expectExceptionMessage("Invalid callback given");
         new LazyOption('invalidCallback');
     }
 
-    /**
-     * @expectedException \InvalidArgumentException
-     * @expectedExceptionMessage Invalid callback given
-     */
     public function testInvalidCallbackAndCreate()
     {
+        $this->expectException(InvalidArgumentException::class);
+        $this->expectExceptionMessage("Invalid callback given");
         LazyOption::create('invalidCallback');
     }
 
@@ -174,20 +171,12 @@ public function testOrElse()
 
     public function testFoldLeftRight()
     {
-        $callback = function() { };
+        $option   = Option::fromValue(5);
+        $callback = function($i) { return $i + 1; };
 
-        $option = $this->getMockForAbstractClass('PhpOption\Option');
-        $option->expects($this->once())
-            ->method('foldLeft')
-            ->with(5, $callback)
-            ->will($this->returnValue(6));
         $lazyOption = new LazyOption(function() use ($option) { return $option; });
         $this->assertSame(6, $lazyOption->foldLeft(5, $callback));
 
-        $option->expects($this->once())
-            ->method('foldRight')
-            ->with(5, $callback)
-            ->will($this->returnValue(6));
         $lazyOption = new LazyOption(function() use ($option) { return $option; });
         $this->assertSame(6, $lazyOption->foldRight(5, $callback));
     }
@@ -204,4 +193,13 @@ public function testFilterIsOneOf()
         $this->assertSame($some, $lazy_opt->filterIsOneOf([stdClass::class, 'unknown']));
         $this->assertSame($some, $lazy_opt->filterIsOneOf(new ArrayIterator([stdClass::class, 'unknown'])));
     }
+
+    public function testToString()
+    {
+        $lazy_opt = LazyOption::create(function() { return Option::fromValue(1); });
+
+        $this->assertEquals('LazyOption(...not evaluated...)', $lazy_opt->__toString());
+        $lazy_opt->getOrElse(0);
+        $this->assertEquals('LazyOption(Some(1))', $lazy_opt->__toString());
+    }
 }
diff --git a/tests/PhpOption/Tests/NoneTest.php b/tests/PhpOption/Tests/NoneTest.php
@@ -2,19 +2,19 @@
 
 namespace PhpOption\Tests;
 
-use stdClass;
+use LogicException;
 use PhpOption\None;
 use PhpOption\Some;
+use RuntimeException;
+use stdClass;
 
 class NoneTest extends \PHPUnit_Framework_TestCase
 {
     private $none;
 
-    /**
-     * @expectedException \RuntimeException
-     */
     public function testGet()
     {
+        $this->expectException(RuntimeException::class);
         $none = None::create();
         $none->get();
     }
@@ -31,13 +31,11 @@ public function testGetOrCall()
         $this->assertEquals('foo', $none->getOrCall(function() { return 'foo'; }));
     }
 
-    /**
-     * @expectedException \RuntimeException
-     * @expectedExceptionMessage Not Found!
-     */
     public function testGetOrThrow()
     {
-        None::create()->getOrThrow(new \RuntimeException('Not Found!'));
+        $this->expectException(RuntimeException::class);
+        $this->expectExceptionMessage("Not Found!");
+        None::create()->getOrThrow(new RuntimeException('Not Found!'));
     }
 
     public function testIsEmpty()
@@ -55,42 +53,42 @@ public function testOrElse()
     public function testifDefined()
     {
         $this->assertNull($this->none->ifDefined(function() {
-            throw new \LogicException('Should never be called.');
+            throw new LogicException('Should never be called.');
         }));
     }
 
     public function testForAll()
     {
         $this->assertSame($this->none, $this->none->forAll(function() {
-            throw new \LogicException('Should never be called.');
+            throw new LogicException('Should never be called.');
         }));
     }
 
     public function testMap()
     {
         $this->assertSame($this->none, $this->none->map(function() {
-            throw new \LogicException('Should not be called.');
+            throw new LogicException('Should not be called.');
         }));
     }
 
     public function testFlatMap()
     {
         $this->assertSame($this->none, $this->none->flatMap(function() {
-            throw new \LogicException('Should not be called.');
+            throw new LogicException('Should not be called.');
         }));
     }
 
     public function testFilter()
     {
         $this->assertSame($this->none, $this->none->filter(function() {
-            throw new \LogicException('Should not be called.');
+            throw new LogicException('Should not be called.');
         }));
     }
 
     public function testFilterNot()
     {
         $this->assertSame($this->none, $this->none->filterNot(function() {
-            throw new \LogicException('Should not be called.');
+            throw new LogicException('Should not be called.');
         }));
     }
 

diff --git a/tests/PhpOption/Tests/OptionTest.php b/tests/PhpOption/Tests/OptionTest.php
@@ -2,10 +2,11 @@
 
 namespace PhpOption\Tests;
 
+use LogicException;
+use PhpOption\LazyOption;
 use PhpOption\None;
-use PhpOption\Some;
 use PhpOption\Option;
-use PhpOption\LazyOption;
+use PhpOption\Some;
 
 class OptionTest extends \PHPUnit_Framework_TestCase
 {
@@ -62,7 +63,7 @@ public function testOrElseWithNoneAsFirst()
 
     public function testOrElseWithLazyOptions()
     {
-        $throws = function() { throw new \LogicException('Should never be called.'); };
+        $throws = function() { throw new LogicException('Should never be called.'); };
 
         $a = new Some('a');
         $b = new LazyOption($throws);
@@ -72,11 +73,11 @@ public function testOrElseWithLazyOptions()
 
     public function testOrElseWithMultipleAlternatives()
     {
-        $throws = new LazyOption(function() { throw new \LogicException('Should never be called.'); });
+        $throws = new LazyOption(function() { throw new LogicException('Should never be called.'); });
         $returns = new LazyOption(function() { return new Some('foo'); });
 
         $a = None::create();
 
         $this->assertEquals('foo', $a->orElse($returns)->orElse($throws)->get());
     }
-}
+}