Add class builder

lib/PHPParser/Builder.php

@@ -0,0 +1,11 @@
+<?php
+
+interface PHPParser_Builder
+{
+    /**
+     * Returns the built node.
+     *
+     * @return PHPParser_Node The built node
+     */
+    public function getNode();
+}

lib/PHPParser/Builder/Class.php

@@ -0,0 +1,169 @@
+<?php
+
+class PHPParser_Builder_Class implements PHPParser_Builder
+{
+    protected $name;
+
+    protected $extends;
+    protected $implements;
+    protected $type;
+
+    protected $uses;
+    protected $constants;
+    protected $properties;
+    protected $methods;
+
+    /**
+     * Creates a class builder.
+     *
+     * @param string $name Name of the class
+     */
+    public function __construct($name) {
+        $this->name = $name;
+
+        $this->type = 0;
+        $this->extends = null;
+        $this->implements = array();
+
+        $this->uses = $this->constants = $this->properties = $this->methods = array();
+    }
+
+    /**
+     * Extends a class.
+     *
+     * @param PHPParser_Node_Name|string $class Name of class to extend
+     *
+     * @return PHPParser_Builder_Class The builder instance (for fluid interface)
+     */
+    public function extend($class) {
+        $this->extends = $this->normalizeName($class);
+
+        return $this;
+    }
+
+    /**
+     * Implements one or more interfaces.
+     *
+     * @param PHPParser_Node_Name|string $interface Name of interface to implement
+     * @param PHPParser_Node_Name|string $...       More interfaces to implement
+     *
+     * @return PHPParser_Builder_Class The builder instance (for fluid interface)
+     */
+    public function implement() {
+        foreach (func_get_args() as $interface) {
+            $this->implements[] = $this->normalizeName($interface);
+        }
+
+        return $this;
+    }
+
+    /**
+     * Makes the class abstract.
+     *
+     * @return PHPParser_Builder_Class The builder instance (for fluid interface)
+     */
+    public function makeAbstract() {
+        $this->type = PHPParser_Node_Stmt_Class::MODIFIER_ABSTRACT;
+
+        return $this;
+    }
+
+    /**
+     * Makes the class final.
+     *
+     * @return PHPParser_Builder_Class The builder instance (for fluid interface)
+     */
+    public function makeFinal() {
+        $this->type = PHPParser_Node_Stmt_Class::MODIFIER_FINAL;
+
+        return $this;
+    }
+
+    /**
+     * Adds a statement.
+     *
+     * @param PHPParser_Node|PHPParser_Builder $stmt The statement to add
+     *
+     * @return PHPParser_Builder_Class The builder instance (for fluid interface)
+     */
+    public function addStmt($stmt) {
+        $stmt = $this->normalizeNode($stmt);
+
+        $targets = array(
+            'Stmt_TraitUse'    => &$this->uses,
+            'Stmt_ClassConst'  => &$this->constants,
+            'Stmt_Property'    => &$this->properties,
+            'Stmt_ClassMethod' => &$this->methods,
+        );
+
+        $type = $stmt->getType();
+        if (!isset($targets[$type])) {
+            throw new LogicException(sprintf('Unexpected node of type "%s"', $type));
+        }
+
+        $targets[$type][] = $stmt;
+
+        return $this;
+    }
+
+    /**
+     * Adds multiple statements.
+     *
+     * @param array $stmts The statements to add
+     *
+     * @return PHPParser_Builder_Class The builder instance (for fluid interface)
+     */
+    public function addStmts(array $stmts) {
+        foreach ($stmts as $stmt) {
+            $this->addStmt($stmt);
+        }
+
+        return $this;
+    }
+
+    /**
+     * Returns the built class node.
+     *
+     * @return PHPParser_Node The built class node
+     */
+    public function getNode() {
+        return new PHPParser_Node_Stmt_Class($this->name, array(
+            'type' => $this->type,
+            'extends' => $this->extends,
+            'implements' => $this->implements,
+            'stmts' => array_merge($this->uses, $this->constants, $this->properties, $this->methods),
+        ));
+    }
+
+    /**
+     * Normalizes a name: Converts plain string names to PHPParser_Node_Name.
+     *
+     * @param PHPParser_Node_Name|string $name The name to normalize
+     *
+     * @return PHPParser_Node_Name The normalized name
+     */
+    protected function normalizeName($name) {
+        if ($name instanceof PHPParser_Node_Name) {
+            return $name;
+        } else {
+            return new PHPParser_Node_Name($name);
+        }
+    }
+
+    /**
+     * Normalizes a node: Converts builder objects to nodes.
+     *
+     * @param PHPParser_Node|PHPParser_Builder $node The node to normalize
+     *
+     * @return PHPParser_Node The normalized node
+     */
+    protected function normalizeNode($node) {
+        if ($node instanceof PHPParser_Builder) {
+            return $node->getNode();
+        } elseif ($node instanceof PHPParser_Node) {
+            return $node;
+        }
+
+        throw new LogicException('Expected node or builder object');
+    }
+}

lib/PHPParser/BuilderFactory.php

@@ -0,0 +1,23 @@
+<?php
+
+/**
+ * @method PHPParser_Builder_Class class(string $name) Create a class builder
+ */
+class PHPParser_BuilderFactory
+{
+    /*
+     * "class" is a reserved keyword, so we implement the method as _class()
+     * and redirect class() to it through __call magic
+     */
+    protected function _class($name) {
+        return new PHPParser_Builder_Class($name);
+    }
+
+    public function __call($name, array $args) {
+        if ('class' === $name) {
+            return call_user_func_array(array($this, '_class'), $args);
+        }
+
+        throw new LogicException(sprintf('Method "%s" does not exist', $name));
+    }
+}

test/PHPParser/Tests/Builder/ClassTest.php

@@ -0,0 +1,81 @@
+<?php
+
+class PHPParser_Tests_Builder_ClassTest extends PHPUnit_Framework_TestCase
+{
+    protected function createClassBuilder($class) {
+        return new PHPParser_Builder_Class($class);
+    }
+
+    public function testExtendsImplements() {
+        $node = $this->createClassBuilder('SomeLogger')
+            ->extend('BaseLogger')
+            ->implement('Namespaced\Logger', new PHPParser_Node_Name('SomeInterface'))
+            ->getNode()
+        ;
+
+        $this->assertEquals(
+            new PHPParser_Node_Stmt_Class('SomeLogger', array(
+                'extends' => new PHPParser_Node_Name('BaseLogger'),
+                'implements' => array(
+                    new PHPParser_Node_Name('Namespaced\Logger'),
+                    new PHPParser_Node_Name('SomeInterface')
+                ),
+            )),
+            $node
+        );
+    }
+
+    public function testAbstract() {
+        $node = $this->createClassBuilder('Test')
+            ->makeAbstract()
+            ->getNode()
+        ;
+
+        $this->assertEquals(
+            new PHPParser_Node_Stmt_Class('Test', array(
+                'type' => PHPParser_Node_Stmt_Class::MODIFIER_ABSTRACT
+            )),
+            $node
+        );
+    }
+
+    public function testFinal() {
+        $node = $this->createClassBuilder('Test')
+            ->makeFinal()
+            ->getNode()
+        ;
+
+        $this->assertEquals(
+            new PHPParser_Node_Stmt_Class('Test', array(
+                'type' => PHPParser_Node_Stmt_Class::MODIFIER_FINAL
+            )),
+            $node
+        );
+    }
+
+    public function testStatementOrder() {
+        $method = new PHPParser_Node_Stmt_ClassMethod('testMethod');
+        $property = new PHPParser_Node_Stmt_Property(
+            PHPParser_Node_Stmt_Class::MODIFIER_PUBLIC,
+            array(new PHPParser_Node_Stmt_PropertyProperty('testProperty'))
+        );
+        $const = new PHPParser_Node_Stmt_ClassConst(array(
+            new PHPParser_Node_Const('TEST_CONST', new PHPParser_Node_Scalar_String('ABC'))
+        ));
+        $use = new PHPParser_Node_Stmt_TraitUse(array(new PHPParser_Node_Name('SomeTrait')));
+
+        $node = $this->createClassBuilder('Test')
+            ->addStmt($method)
+            ->addStmt($property)
+            ->addStmts(array($const, $use))
+            ->getNode()
+        ;
+
+        $this->assertEquals(
+            new PHPParser_Node_Stmt_Class('Test', array(
+                'stmts' => array($use, $const, $property, $method)
+            )),
+            $node
+        );
+    }
+}

test/PHPParser/Tests/BuilderFactoryTest.php

@@ -0,0 +1,13 @@
+<?php
+
+class PHPParser_Tests_BuilderFactoryTest extends PHPUnit_Framework_TestCase
+{
+    public function testCreateClassBuilder() {
+        $factory = new PHPParser_BuilderFactory;
+
+        $builder = $factory->class('Test');
+        $this->assertInstanceOf('PHPParser_Builder_Class', $builder);
+
+        $this->assertEquals(new PHPParser_Node_Stmt_Class('Test'), $builder->getNode());
+    }
+}