moved all functionality to Query class

Author: transistive

src/ExpressionList.php

@@ -74,21 +74,6 @@ public function __construct(array $expressions)
         $this->expressions = $expressions;
     }
 
-    /**
-     * Constructs an expression list from literals (eg. strings, numbers and booleans)
-     * @param iterable $literals
-     * @return static
-     */
-    public static function fromLiterals(iterable $literals): self
-    {
-        $tbr = [];
-        foreach ($literals as $literal) {
-            $tbr[] = Literal::fromLiteral($literal);
-        }
-
-        return new self($tbr);
-    }
-
     /**
      * @inheritDoc
      */

src/Literals/Boolean.php

@@ -27,7 +27,7 @@
 /**
  * Represents a boolean (true or false) literal.
  */
-class Boolean extends Literal implements BooleanType
+class Boolean implements BooleanType
 {
     use BooleanTypeTrait;
 

src/Literals/Decimal.php

@@ -27,7 +27,7 @@
 /**
  * Represents a decimal (integer or float) literal.
  */
-class Decimal extends Literal implements NumeralType
+class Decimal implements NumeralType
 {
     use NumeralTypeTrait;
 

src/Literals/Literal.php

@@ -30,7 +30,7 @@
  *
  * @see https://neo4j.com/docs/cypher-manual/current/syntax/expressions/#cypher-expressions-string-literals
  */
-class StringLiteral extends Literal implements StringType
+class StringLiteral implements StringType
 {
     use StringTypeTrait;
 

src/Literals/StringLiteral.php

@@ -54,6 +54,14 @@
 use WikibaseSolutions\CypherDSL\Types\StructuralTypes\NodeType;
 use WikibaseSolutions\CypherDSL\Types\StructuralTypes\PathType;
 use WikibaseSolutions\CypherDSL\Types\StructuralTypes\StructuralType;
+use function get_class;
+use function gettype;
+use function is_bool;
+use function is_float;
+use function is_int;
+use function is_object;
+use function is_string;
+use function method_exists;
 
 /**
  * Builder class for building complex Cypher queries.
@@ -125,25 +133,25 @@ 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");
     }
 
     /**
@@ -157,6 +165,23 @@ public static function list(array $expressions): ExpressionList
         return new ExpressionList($expressions);
     }
 
+    /**
+     * Creates a list of literal expressions.
+     *
+     * @param mixed[] $expressions
+     *
+     * @return ExpressionList
+     */
+    public static function literalList(iterable $literals): ExpressionList
+    {
+        $tbr = [];
+        foreach ($literals as $literal) {
+            $tbr[] = self::literal($literal);
+        }
+
+        return new ExpressionList($tbr);
+    }
+
     /**
      * Creates a property map.
      *

src/Query.php

@@ -40,20 +40,6 @@ public function testEmpty(): void
         $this->assertSame("[]", $expressionList->toQuery());
     }
 
-    public function testFromLiterals(): void
-    {
-        $expressionList = ExpressionList::fromLiterals(['a', 'b', 234.3, 1, true, false]);
-
-        $this->assertSame("['a', 'b', 234.3, 1, true, false]", $expressionList->toQuery());
-    }
-
-    public function testFromLiteralsError(): void
-    {
-        $expressionList = ExpressionList::fromLiterals(['a', 'b', 234.3, 1, true, false]);
-        $this->expectException(TypeError::class);
-        $expressionList = ExpressionList::fromLiterals([$expressionList]);
-    }
-
     /**
      * @dataProvider provideOneDimensionalData
      * @param array $expressions

tests/Unit/ExpressionListTest.php

@@ -21,7 +21,9 @@
 
 namespace WikibaseSolutions\CypherDSL\Tests\Unit;
 
+use InvalidArgumentException;
 use PHPUnit\Framework\TestCase;
+use TypeError;
 use WikibaseSolutions\CypherDSL\Assignment;
 use WikibaseSolutions\CypherDSL\Clauses\Clause;
 use WikibaseSolutions\CypherDSL\Clauses\MatchClause;
@@ -373,6 +375,67 @@ public function testBuildEmpty()
         $this->assertSame("", $query->build());
     }
 
+    public function testInt(): void
+    {
+        $literal = Query::literal(1);
+        self::assertInstanceOf(Decimal::class, $literal);
+        self::assertEquals('1', $literal->toQuery());
+    }
+
+    public function testFloat(): void
+    {
+        $literal = Query::literal(1.2);
+        self::assertInstanceOf(Decimal::class, $literal);
+        self::assertEquals('1.2', $literal->toQuery());
+    }
+
+    public function testString(): void
+    {
+        $literal = Query::literal('abc');
+        self::assertInstanceOf(StringLiteral::class, $literal);
+        self::assertEquals("'abc'", $literal->toQuery());
+    }
+
+    public function testStringAble(): void
+    {
+        $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(): void
+    {
+        $literal = Query::literal(true);
+        self::assertInstanceOf(Boolean::class, $literal);
+        self::assertEquals("true", $literal->toQuery());
+    }
+
+    public function testInvalidLiteral(): void
+    {
+        $literal = Query::literal(true);
+        $this->expectException(InvalidArgumentException::class);
+        Query::literal($literal);
+    }
+
+    public function testFromLiterals(): void
+    {
+        $expressionList = Query::literalList(['a', 'b', 234.3, 1, true, false]);
+
+        $this->assertSame("['a', 'b', 234.3, 1, true, false]", $expressionList->toQuery());
+    }
+
+    public function testFromLiteralsError(): void
+    {
+        $expressionList = Query::literalList(['a', 'b', 234.3, 1, true, false]);
+        $this->expectException(InvalidArgumentException::class);
+        $expressionList = Query::literalList([$expressionList]);
+    }
+
     public function testWikiExamples()
     {
         /*