/**
* non_empty_parameter_list_1
* optional_class_type T_VARIABLE
*/
protected function non_empty_parameter_list_1($params)
{
$name = preg_replace('/^\\$/', '', $params[1]->getValue());
$argument = new Stagehand_PHP_Class_Method_Argument($name);
$argument->setRequirement(true);
if ($params[0]) {
$argument->setTypeHinting($params[0]);
}
return array($argument);
}
/**
* @test
*/
public function setMethodAndUse()
{
$className = 'ExampleForMethod';
$class = new Stagehand_PHP_Class($className);
$methodFoo = new Stagehand_PHP_Class_Method('foo');
$methodFoo->setCode('return 10;');
$argumentBar = new Stagehand_PHP_Class_Method_Argument('bar');
$methodBar = new Stagehand_PHP_Class_Method('bar');
$methodBar->addArgument($argumentBar);
$methodBar->setCode('return $bar;');
$argumentBaz = new Stagehand_PHP_Class_Method_Argument('baz');
$argumentBaz->setRequirement(false);
$argumentBaz->setValue(array(10, 30, 50));
$methodBaz = new Stagehand_PHP_Class_Method('baz');
$methodBaz->addArgument($argumentBaz);
$methodBaz->setCode('return $baz[1];');
$methodQux = new Stagehand_PHP_Class_Method('qux');
$methodQux->defineProtected();
$methodQux->setCode('return true;');
$methodQuux = new Stagehand_PHP_Class_Method('quux');
$methodQuux->definePrivate();
$methodQuux->setCode('return true;');
$class->addMethod($methodFoo);
$class->addMethod($methodBar);
$class->addMethod($methodBaz);
$class->addMethod($methodQux);
$class->addMethod($methodQuux);
$class->load();
$instance = new $className();
$refClass = new ReflectionClass($className);
$foo = $refClass->getMethod('foo');
$bar = $refClass->getMethod('bar');
$baz = $refClass->getMethod('baz');
$qux = $refClass->getMethod('qux');
$quux = $refClass->getMethod('quux');
$this->assertTrue($foo->isPublic());
$this->assertTrue($bar->isPublic());
$this->assertTrue($baz->isPublic());
$this->assertTrue($qux->isProtected());
$this->assertTrue($quux->isPrivate());
$this->assertEquals($instance->foo(), 10);
$this->assertEquals($instance->bar(20), 20);
$this->assertEquals($instance->baz(), 30);
}
/**
* Sets a argument.
*
* @param Stagehand_PHP_Class_Argument $argument
*/
public function setArgument(Stagehand_PHP_Class_Method_Argument $argument)
{
$this->_arguments[$argument->getName()] = $argument;
}
/**
* A function for test of code generator.
*
* @param string $name class name
*/
function define_class_for_code_genration_test()
{
$className = 'ExampleForCodeGenerationTest';
$class = new Stagehand_PHP_Class($className);
$publicProperty = new Stagehand_PHP_Class_Property('a');
$protectedProperty = new Stagehand_PHP_Class_Property('b', 100);
$privateProperty = new Stagehand_PHP_Class_Property('c', array(1, 3, 5));
$staticProperty = new Stagehand_PHP_Class_Property('d', 'static');
$protectedProperty->defineProtected();
$privateProperty->definePrivate();
$staticProperty->defineStatic();
$argumentA = new Stagehand_PHP_Class_Method_Argument('a');
$argumentB = new Stagehand_PHP_Class_Method_Argument('b');
$argumentC = new Stagehand_PHP_Class_Method_Argument('c');
$argumentD = new Stagehand_PHP_Class_Method_Argument('d');
$argumentE = new Stagehand_PHP_Class_Method_Argument('e');
$argumentF = new Stagehand_PHP_Class_Method_Argument('f');
$argumentB->setTypeHinting('array');
$argumentC->setRequirement(false);
$argumentD->setRequirement(false);
$argumentD->setValue('d');
$argumentE->setRequirement(false);
$argumentE->setValue(array(2, 4, 6));
$argumentF->setReference();
$publicMethod = new Stagehand_PHP_Class_Method('foo');
$protectedMethod = new Stagehand_PHP_Class_Method('bar');
$privateMethod = new Stagehand_PHP_Class_Method('baz');
$staticMethod = new Stagehand_PHP_Class_Method('qux');
$abstractMethod = new Stagehand_PHP_Class_Method('quux');
$abstractStaticMethod = new Stagehand_PHP_Class_Method('corge');
$finalMethod = new Stagehand_PHP_Class_Method('grault');
$finalStaticMethod = new Stagehand_PHP_Class_Method('garply');
$referenceMethod = new Stagehand_PHP_Class_Method('waldo');
$protectedMethod->defineProtected();
$protectedMethod->addArgument($argumentA);
$protectedMethod->addArgument($argumentB);
$protectedMethod->setCode('return true;');
$privateMethod->definePrivate();
$privateMethod->addArgument($argumentC);
$privateMethod->addArgument($argumentD);
$privateMethod->setCode('$c += 1;
return $d;');
$staticMethod->defineStatic();
$staticMethod->addArgument($argumentE);
$abstractMethod->defineAbstract();
$abstractStaticMethod->defineAbstract();
$abstractStaticMethod->defineStatic();
$finalMethod->defineFinal();
$finalMethod->addArgument($argumentF);
$finalStaticMethod->defineFinal();
$finalStaticMethod->defineStatic();
$referenceMethod->setReference();
$constant1 = new Stagehand_PHP_Class_Constant('A');
$constant2 = new Stagehand_PHP_Class_Constant('B', 10);
$constant3 = new Stagehand_PHP_Class_Constant('C', 'text constant');
$class->addProperty($publicProperty);
$class->addProperty($protectedProperty);
$class->addProperty($privateProperty);
$class->addProperty($staticProperty);
$class->addMethod($publicMethod);
$class->addMethod($protectedMethod);
$class->addMethod($privateMethod);
$class->addMethod($staticMethod);
$class->addMethod($abstractMethod);
$class->addMethod($abstractStaticMethod);
$class->addMethod($finalMethod);
$class->addMethod($finalStaticMethod);
$class->addMethod($referenceMethod);
$class->addConstant($constant1);
$class->addConstant($constant2);
$class->addConstant($constant3);
return $class;
}
/**
* @test
*/
public function renderInterface()
{
$name = 'getFoo';
$method = new Stagehand_PHP_Class_Method($name);
$method->setCode('$a = 0;
return 1;');
$this->assertEquals($method->renderInterface(), <<<EOF
public function getFoo();
EOF
);
$foo = new Stagehand_PHP_Class_Method_Argument('foo');
$bar = new Stagehand_PHP_Class_Method_Argument('bar');
$bar->setRequirement(false);
$bar->setValue(10);
$method->addArgument($foo);
$method->addArgument($bar);
$this->assertEquals($method->renderInterface(), <<<EOF
public function getFoo(\$foo, \$bar = 10);
EOF
);
$method->defineProtected();
$this->assertNull($method->renderInterface());
$method->definePrivate();
$this->assertNull($method->renderInterface());
}
/**
* @test
*/
public function useParsableValue()
{
$argument = new Stagehand_PHP_Class_Method_Argument('foo');
$argument->setRequirement(false);
$argument->setValue('Foo::value', true);
$this->assertTrue($argument->isParsable());
$this->assertEquals($argument->getValue(), 'Foo::value');
$this->assertEquals($argument->render(), '$foo = Foo::value');
$argument->setValue('Foo::value');
$this->assertFalse($argument->isParsable());
$this->assertEquals($argument->getValue(), 'Foo::value');
$this->assertEquals($argument->render(), '$foo = \'Foo::value\'');
}
