Merge pull request #4 from transistive/literals

Literals

Author: marijnvanwezel

src/Query.php

@@ -125,35 +125,42 @@ public static function variable(string $variable): Variable
      * Creates a new literal from the given value. This function automatically constructs the appropriate
      * class based on the type of the value given.
      *
-     * @param integer|float|bool|string $literal The literal to construct
+     * @param mixed $literal The literal to construct
      * @return StringLiteral|Boolean|Decimal
      */
     public static function literal($literal): PropertyType
     {
-        $literalType = gettype($literal);
-
-        switch ($literalType) {
-            case "string":
-                return new StringLiteral($literal);
-            case "boolean":
-                return new Boolean($literal);
-            case "double":
-            case "float":
-            case "integer":
-                return new Decimal($literal);
-            default:
-                throw new InvalidArgumentException("The literal type " . $literalType . " is not supported by Cypher");
+        if (is_string($literal) || (is_object($literal) && method_exists($literal, '__toString'))) {
+            return new StringLiteral((string) $literal);
         }
+
+        if (is_bool($literal)) {
+            return new Boolean($literal);
+        }
+
+        if (is_int($literal) || is_float($literal)) {
+            return new Decimal($literal);
+        }
+
+        $actualType = is_object($literal) ? get_class($literal) : gettype($literal);
+
+        throw new InvalidArgumentException("The literal type " . $actualType . " is not supported by Cypher");
     }
 
     /**
      * Creates a list of expressions.
      *
-     * @param AnyType[] $expressions
+     * @param iterable $values
      * @return ExpressionList
      */
-    public static function list(array $expressions): ExpressionList
+    public static function list(iterable $values): ExpressionList
     {
+        $expressions = [];
+        foreach ($values as $value) {
+            $expressions[] = $value instanceof AnyType ?
+                $value : self::literal($value);
+        }
+
         return new ExpressionList($expressions);
     }
 

tests/Unit/InTest.php

@@ -23,7 +23,9 @@
 
 use PHPUnit\Framework\TestCase;
 use TypeError;
+use WikibaseSolutions\CypherDSL\ExpressionList;
 use WikibaseSolutions\CypherDSL\In;
+use WikibaseSolutions\CypherDSL\Literals\StringLiteral;
 use WikibaseSolutions\CypherDSL\Types\AnyType;
 use WikibaseSolutions\CypherDSL\Types\CompositeTypes\ListType;
 use WikibaseSolutions\CypherDSL\Types\PropertyTypes\PropertyType;
@@ -46,6 +48,17 @@ public function testToQuery()
         $this->assertSame("((a IN b) IN c)", $inequality->toQuery());
     }
 
+    public function testInExpressionList()
+    {
+        $inequality = new In($this->getQueryConvertableMock(PropertyType::class, "a"), new ExpressionList([new StringLiteral('a'), new StringLiteral('b')]));
+
+        $this->assertSame("(a IN ['a', 'b'])", $inequality->toQuery());
+
+        $inequality = new In($inequality, $this->getQueryConvertableMock(ListType::class, "c"));
+
+        $this->assertSame("((a IN ['a', 'b']) IN c)", $inequality->toQuery());
+    }
+
     public function testDoesNotAcceptAnyTypeAsOperands()
     {
         $this->expectException(TypeError::class);

tests/Unit/QueryTest.php

@@ -21,6 +21,7 @@
 
 namespace WikibaseSolutions\CypherDSL\Tests\Unit;
 
+use InvalidArgumentException;
 use PHPUnit\Framework\TestCase;
 use WikibaseSolutions\CypherDSL\Assignment;
 use WikibaseSolutions\CypherDSL\Clauses\Clause;
@@ -114,6 +115,77 @@ public function testList()
         $this->assertInstanceOf(ExpressionList::class, $list);
     }
 
+    public function testListOfLiterals()
+    {
+        $list = Query::list(["hello", "world", 1.0, 1, 2, 3, true]);
+
+        $this->assertInstanceOf(ExpressionList::class, $list);
+    }
+
+    public function testListOfMixed()
+    {
+        $list = Query::list([$this->getQueryConvertableMock(AnyType::class, "hello"), "world"]);
+
+        $this->assertInstanceOf(ExpressionList::class, $list);
+    }
+
+    public function testListOfAnyType()
+    {
+        $list = Query::list([$this->getQueryConvertableMock(AnyType::class, "hello"), $this->getQueryConvertableMock(AnyType::class, "world")]);
+
+        $this->assertInstanceOf(ExpressionList::class, $list);
+    }
+
+    public function testNestedList()
+    {
+        $list = Query::list([Query::list([])]);
+
+        $this->assertInstanceOf(ExpressionList::class, $list);
+    }
+
+    public function testIteratorList()
+    {
+        $iterator = new class implements \Iterator {
+            private int $count = 0;
+
+            public function current()
+            {
+                return 1;
+            }
+
+            public function next()
+            {
+                $this->count++;
+                return 1;
+            }
+
+            public function key()
+            {
+                return 0;
+            }
+
+            public function valid()
+            {
+                // In order to avoid an infinite loop
+                return $this->count < 10;
+            }
+
+            public function rewind()
+            {
+            }
+        };
+
+        $list = Query::list($iterator);
+
+        $this->assertInstanceOf(ExpressionList::class, $list);
+    }
+
+    public function testInvalidList()
+    {
+        $this->expectException(InvalidArgumentException::class);
+        Query::list([new class() {}]);
+    }
+
     public function testMap()
     {
         $map = Query::map([]);
@@ -373,6 +445,53 @@ public function testBuildEmpty()
         $this->assertSame("", $query->build());
     }
 
+    public function testInt()
+    {
+        $literal = Query::literal(1);
+        self::assertInstanceOf(Decimal::class, $literal);
+        self::assertEquals('1', $literal->toQuery());
+    }
+
+    public function testFloat()
+    {
+        $literal = Query::literal(1.2);
+        self::assertInstanceOf(Decimal::class, $literal);
+        self::assertEquals('1.2', $literal->toQuery());
+    }
+
+    public function testString()
+    {
+        $literal = Query::literal('abc');
+        self::assertInstanceOf(StringLiteral::class, $literal);
+        self::assertEquals("'abc'", $literal->toQuery());
+    }
+
+    public function testStringAble()
+    {
+        $literal = Query::literal(new class () {
+            public function __toString(): string
+            {
+                return 'stringable abc';
+            }
+        });
+        self::assertInstanceOf(StringLiteral::class, $literal);
+        self::assertEquals("'stringable abc'", $literal->toQuery());
+    }
+
+    public function testBool()
+    {
+        $literal = Query::literal(true);
+        self::assertInstanceOf(Boolean::class, $literal);
+        self::assertEquals("true", $literal->toQuery());
+    }
+
+    public function testInvalidLiteral()
+    {
+        $literal = Query::literal(true);
+        $this->expectException(InvalidArgumentException::class);
+        Query::literal($literal);
+    }
+
     public function testWikiExamples()
     {
         /*