public function testAddDocComment() { $original = <<<'EOF' <?php interface Test { public function test(); } EOF; $expected = <<<'EOF' <?php interface Test { /** * Test */ public function test(); } EOF; $tree = Parser::parseSource($original); /** @var \Pharborist\Objects\InterfaceNode $interface */ $interface = $tree->getStatements()[0]; /** @var \Pharborist\Objects\InterfaceMethodNode $method */ $method = $interface->getStatements()[0]; $comment = DocCommentNode::create('Test'); $method->setDocComment($comment); $this->assertEquals($expected, $tree->getText()); }
/** * @return \Pharborist\Objects\ClassNode */ public function render() { if (empty($this->controller)) { $render = ['#theme' => 'dmu_form', '#module' => $this->target->id(), '#form_id' => $this->formID, '#class' => $this->toTitleCase($this->formID), '#config' => $this->isConfig]; $source = \Drupal::service('renderer')->renderPlain($render); $this->controller = Parser::parseSource($source)->find(Filter::isClass($render['#class']))->get(0); } return $this->controller; }
/** * @requires PHP 5.6 */ public function testIsVariadic() { $doc = <<<'END' <?php function foo($a, $b, ...$c) { } END; /** @var \Pharborist\Functions\FunctionDeclarationNode $func */ $func = Parser::parseSource($doc)->children(Filter::isFunction('foo'))->get(0); $this->assertTrue($func->isVariadic()); $doc = <<<'END' <?php function baz($a, $b, $c) { } END; $func = Parser::parseSource($doc)->children(Filter::isFunction('baz'))->get(0); $this->assertFalse($func->isVariadic()); }
public function testForeignStringKey() { $original = <<<'END' <?php variable_set('bar_wambooli', TRUE); END; $expected = <<<'END' <?php // @FIXME // This looks like another module's variable. You'll need to rewrite this call // to ensure that it uses the correct configuration object. variable_set('bar_wambooli', TRUE); END; $snippet = Parser::parseSource($original); $function_call = $snippet->find(Filter::isFunctionCall('variable_set'))->get(0); $rewritten = $this->plugin->rewrite($function_call, $this->target); $this->assertNull($rewritten); $this->assertSame($expected, $snippet->getText()); }
public function testStringKeyAndUnextractableDefaultValue() { $original = <<<'END' <?php variable_get('foo_wambooli', array()); END; $expected = <<<'END' <?php // @FIXME // Could not extract the default value because it is either indeterminate, or // not scalar. You'll need to provide a default value in // config/install/@module.settings.yml and config/schema/@module.schema.yml. variable_get('foo_wambooli', array()); END; $snippet = Parser::parseSource($original); $function_call = $snippet->find(Filter::isFunctionCall('variable_get'))->get(0); $rewritten = $this->plugin->rewrite($function_call, $this->target); $this->assertInstanceOf('\\Pharborist\\Objects\\ObjectMethodCallNode', $rewritten); $this->assertEquals('\\Drupal::config(\'foo.settings\')->get(\'foo_wambooli\')', $rewritten->getText()); $this->assertSame($expected, $snippet->getText()); }
/** * Test template file. */ public function testTemplate() { $source = <<<'EOF' <p>This is a template file</p> <p>Hello, <?=$name?>. Welcome to <?=$lego . 'world'?>!</p> <?php code(); ?><h1>End of template</h1><?php more_code(); EOF; $tree = Parser::parseSource($source); $this->assertEquals($source, $tree->getText()); /** @var TemplateNode[] $templates */ $templates = $tree->find(Filter::isInstanceOf('\\Pharborist\\TemplateNode')); $template = $templates[0]; $this->assertEquals(5, $template->childCount()); /** @var EchoTagStatementNode $echo_tag */ $echo_tag = $template->firstChild()->next(); $this->assertInstanceOf('\\Pharborist\\EchoTagStatementNode', $echo_tag); $this->assertEquals('<?=$name?>', $echo_tag->getText()); $expressions = $echo_tag->getExpressions(); $this->assertEquals('$name', $expressions[0]->getText()); $template = $templates[1]; $this->assertEquals('?><h1>End of template</h1><?php ', $template->getText()); }
public function testRoot() { $source = <<<'EOF' <?php use B\D, C\E as F; test(); F(); new B(); new D(); new F(); B::foo(); D::foo(); my\foo(); B\foo(); A\B::foo(); new F\G(); new namespace\Level\MyClass(); EOF; /** @var RootNode $namespace */ $root = Parser::parseSource($source); /** @var StatementNode[] $statements */ $statements = $root->getStatements(); /** @var ExpressionStatementNode $statement */ $statement = $statements[1]; /** @var FunctionCallNode $function_call */ $function_call = $statement->getExpression(); $name = $function_call->getName(); $this->assertTrue($name->isUnqualified()); $this->assertEquals('test', $name->getText()); $this->assertEquals('\\test', $name->getAbsolutePath()); $statement = $statements[2]; $function_call = $statement->getExpression(); $name = $function_call->getName(); $this->assertTrue($name->isUnqualified()); $this->assertEquals('F', $name->getText()); $this->assertEquals('\\F', $name->getAbsolutePath()); $statement = $statements[3]; /** @var NewNode $new */ $new = $statement->getExpression(); $name = $new->getClassName(); $this->assertTrue($name->isUnqualified()); $this->assertEquals('B', $name->getText()); $this->assertEquals('\\B', $name->getAbsolutePath()); $statement = $statements[4]; $new = $statement->getExpression(); $name = $new->getClassName(); $this->assertTrue($name->isUnqualified()); $this->assertEquals('D', $name->getText()); $this->assertEquals('\\B\\D', $name->getAbsolutePath()); $statement = $statements[5]; $new = $statement->getExpression(); $name = $new->getClassName(); $this->assertTrue($name->isUnqualified()); $this->assertEquals('F', $name->getText()); $this->assertEquals('\\C\\E', $name->getAbsolutePath()); $statement = $statements[6]; /** @var ClassMethodCallNode $class_method_call */ $class_method_call = $statement->getExpression(); $name = $class_method_call->getClassName(); $this->assertTrue($name->isUnqualified()); $this->assertEquals('B', $name->getText()); $this->assertEquals('\\B', $name->getAbsolutePath()); $statement = $statements[7]; $class_method_call = $statement->getExpression(); $name = $class_method_call->getClassName(); $this->assertTrue($name->isUnqualified()); $this->assertEquals('D', $name->getText()); $this->assertEquals('\\B\\D', $name->getAbsolutePath()); $statement = $statements[8]; $function_call = $statement->getExpression(); $name = $function_call->getName(); $this->assertTrue($name->isQualified()); $this->assertEquals('my\\foo', $name->getText()); $this->assertEquals('\\my\\foo', $name->getAbsolutePath()); $statement = $statements[9]; $function_call = $statement->getExpression(); $name = $function_call->getName(); $this->assertTrue($name->isQualified()); $this->assertEquals('B\\foo', $name->getText()); $this->assertEquals('\\B\\foo', $name->getAbsolutePath()); $statement = $statements[10]; $class_method_call = $statement->getExpression(); $name = $class_method_call->getClassName(); $this->assertTrue($name->isQualified()); $this->assertEquals('A\\B', $name->getText()); $this->assertEquals('\\A\\B', $name->getAbsolutePath()); $statement = $statements[11]; $new = $statement->getExpression(); $name = $new->getClassName(); $this->assertTrue($name->isQualified()); $this->assertEquals('F\\G', $name->getText()); $this->assertEquals('\\C\\E\\G', $name->getAbsolutePath()); $statement = $statements[12]; $new = $statement->getExpression(); $name = $new->getClassName(); $this->assertTrue($name->isRelative()); $this->assertEquals('namespace\\Level\\MyClass', $name->getText()); $this->assertEquals('\\Level\\MyClass', $name->getAbsolutePath()); }
public function testGetTypes() { $source = <<<'EOF' <?php use MyNamespace\MyClass; use MyNamespace\SomeClass as TestClass; class Test { /** * A property using class. * * @var MyClass */ private $a; /** * Property using class alias. * * @var TestClass */ private $b; /** * An array property. * * @var array */ private $data; /** * A callable property. * * @var callable */ private $callback; /** * An integer property. * * @var int */ private $num; /** * A generic property. */ private $generic; } EOF; $tree = Parser::parseSource($source); /** @var ClassNode $class */ $class = $tree->children(Filter::isInstanceOf('\\Pharborist\\Objects\\ClassNode'))[0]; $properties = $class->getProperties(); $this->assertEquals(['\\MyNamespace\\MyClass'], $properties[0]->getTypes()); $this->assertEquals(['\\MyNamespace\\SomeClass'], $properties[1]->getTypes()); $this->assertEquals(['array'], $properties[2]->getTypes()); $this->assertEquals(['callable'], $properties[3]->getTypes()); $this->assertEquals(['int'], $properties[4]->getTypes()); $this->assertEquals(['mixed'], $properties[5]->getTypes()); }
/** * @requires PHP 5.6 */ public function testVariadic() { $source = <<<'EOF' <?php function foo($args) { } EOF; $tree = Parser::parseSource($source); /** @var \Pharborist\Functions\FunctionDeclarationNode $function */ $function = $tree->children(Filter::isInstanceOf('\\Pharborist\\Functions\\FunctionDeclarationNode'))[0]; $parameter = $function->getParameter(0); $this->assertFalse($parameter->isVariadic()); $parameter->setVariadic(TRUE); $this->assertTrue($parameter->isVariadic()); $this->assertEquals('...$args', $parameter->getText()); }
public function testChainMethodCall() { $object = Token::variable('$object'); $method_call = ObjectMethodCallNode::create($object, 'someMethod'); $chained_call = $method_call->appendMethodCall('chained'); $this->assertEquals('$object->someMethod()', $chained_call->getObject()->getText()); $this->assertEquals('chained', $chained_call->getMethodName()->getText()); $source = <<<'EOF' <?php $object->someMethod(); EOF; $tree = Parser::parseSource($source); /** @var ExpressionStatementNode $expr_statement */ $expr_statement = $tree->firstChild()->next(); /** @var ObjectMethodCallNode $method_call */ $method_call = $expr_statement->getExpression(); $method_call->appendMethodCall('chained'); $expected = <<<'EOF' <?php $object->someMethod()->chained(); EOF; $this->assertEquals($expected, $tree->getText()); }
public function testRoot() { $source = <<<END <?php test(); END; $tree = Parser::parseSource($source); $node = $tree->firstChild()->next(); $this->assertTrue($node->hasRoot()); $this->assertSame($tree, $node->getRoot()); $node = $this->createNode('orphan'); $this->assertFalse($node->hasRoot()); $this->assertNull($node->getRoot()); }