2010-01-04 14:26:20 +00:00
< ? php
2011-01-15 13:29:43 +00:00
/*
* This file is part of the Symfony package .
*
2011-03-06 11:40:06 +00:00
* ( c ) Fabien Potencier < fabien @ symfony . com >
2011-01-15 13:29:43 +00:00
*
* For the full copyright and license information , please view the LICENSE
* file that was distributed with this source code .
*/
2010-08-20 22:09:55 +01:00
namespace Symfony\Component\DependencyInjection\Dumper ;
2010-01-04 14:26:20 +00:00
2011-01-05 11:13:27 +00:00
use Symfony\Component\DependencyInjection\Variable ;
use Symfony\Component\DependencyInjection\Definition ;
2010-08-20 22:09:55 +01:00
use Symfony\Component\DependencyInjection\ContainerBuilder ;
use Symfony\Component\DependencyInjection\Container ;
use Symfony\Component\DependencyInjection\ContainerInterface ;
use Symfony\Component\DependencyInjection\Reference ;
use Symfony\Component\DependencyInjection\Parameter ;
2011-12-04 23:51:22 +00:00
use Symfony\Component\DependencyInjection\Exception\InvalidArgumentException ;
use Symfony\Component\DependencyInjection\Exception\RuntimeException ;
use Symfony\Component\DependencyInjection\Exception\ServiceCircularReferenceException ;
2010-01-04 14:26:20 +00:00
/**
* PhpDumper dumps a service container as a PHP class .
*
2011-03-06 11:40:06 +00:00
* @ author Fabien Potencier < fabien @ symfony . com >
2011-01-05 11:13:27 +00:00
* @ author Johannes M . Schmitt < schmittjoh @ gmail . com >
2011-07-20 09:50:27 +01:00
*
* @ api
2010-01-04 14:26:20 +00:00
*/
class PhpDumper extends Dumper
{
2011-01-05 11:13:27 +00:00
/**
* Characters that might appear in the generated variable name as first character
* @ var string
*/
const FIRST_CHARS = 'abcdefghijklmnopqrstuvwxyz' ;
/**
* Characters that might appear in the generated variable name as any but the first character
* @ var string
*/
const NON_FIRST_CHARS = 'abcdefghijklmnopqrstuvwxyz0123456789_' ;
2011-03-11 13:50:46 +00:00
private $inlinedDefinitions ;
private $definitionVariables ;
private $referenceVariables ;
private $variableCount ;
private $reservedVariables = array ( 'instance' , 'class' );
2011-01-05 11:13:27 +00:00
2011-02-13 18:06:41 +00:00
/**
* { @ inheritDoc }
2011-07-20 09:50:27 +01:00
*
* @ api
2011-02-13 18:06:41 +00:00
*/
2011-01-05 11:13:27 +00:00
public function __construct ( ContainerBuilder $container )
{
parent :: __construct ( $container );
$this -> inlinedDefinitions = new \SplObjectStorage ;
}
2010-05-06 12:25:53 +01:00
/**
* Dumps the service container as a PHP class .
*
* Available options :
*
* * class : The class name
* * base_class : The base class name
*
* @ param array $options An array of options
*
* @ return string A PHP class representing of the service container
2011-07-20 09:50:27 +01:00
*
* @ api
2010-05-06 12:25:53 +01:00
*/
public function dump ( array $options = array ())
{
$options = array_merge ( array (
'class' => 'ProjectServiceContainer' ,
'base_class' => 'Container' ,
), $options );
2011-01-30 14:06:45 +00:00
$code = $this -> startClass ( $options [ 'class' ], $options [ 'base_class' ]);
if ( $this -> container -> isFrozen ()) {
$code .= $this -> addFrozenConstructor ();
} else {
$code .= $this -> addConstructor ();
}
$code .=
2010-05-06 12:25:53 +01:00
$this -> addServices () .
$this -> addDefaultParametersMethod () .
$this -> endClass ()
;
2011-01-30 14:06:45 +00:00
return $code ;
2010-05-06 12:25:53 +01:00
}
2011-02-13 18:06:41 +00:00
/**
* Generates Service local temp variables .
*
2011-03-04 14:26:00 +00:00
* @ param string $cId
* @ param string $definition
2011-12-13 07:50:54 +00:00
*
2011-02-13 18:06:41 +00:00
* @ return string
*/
2011-03-11 13:50:46 +00:00
private function addServiceLocalTempVariables ( $cId , $definition )
2011-01-05 11:13:27 +00:00
{
static $template = " \$ %s = %s; \n " ;
$localDefinitions = array_merge (
array ( $definition ),
$this -> getInlinedDefinitions ( $definition )
);
$calls = $behavior = array ();
foreach ( $localDefinitions as $iDefinition ) {
$this -> getServiceCallsFromArguments ( $iDefinition -> getArguments (), $calls , $behavior );
$this -> getServiceCallsFromArguments ( $iDefinition -> getMethodCalls (), $calls , $behavior );
2011-03-04 14:26:00 +00:00
$this -> getServiceCallsFromArguments ( $iDefinition -> getProperties (), $calls , $behavior );
2011-01-05 11:13:27 +00:00
}
$code = '' ;
foreach ( $calls as $id => $callCount ) {
if ( 'service_container' === $id || $id === $cId ) {
continue ;
}
if ( $callCount > 1 ) {
$name = $this -> getNextVariableName ();
$this -> referenceVariables [ $id ] = new Variable ( $name );
if ( ContainerInterface :: EXCEPTION_ON_INVALID_REFERENCE === $behavior [ $id ]) {
$code .= sprintf ( $template , $name , $this -> getServiceCall ( $id ));
} else {
$code .= sprintf ( $template , $name , $this -> getServiceCall ( $id , new Reference ( $id , ContainerInterface :: NULL_ON_INVALID_REFERENCE )));
}
}
}
if ( '' !== $code ) {
$code .= " \n " ;
}
return $code ;
}
2011-02-13 18:06:41 +00:00
/**
* Generates the require_once statement for service includes .
*
* @ param string $id The service id
2011-03-04 14:26:00 +00:00
* @ param Definition $definition
2011-12-13 07:50:54 +00:00
*
2011-02-13 18:06:41 +00:00
* @ return string
*/
2011-03-11 13:50:46 +00:00
private function addServiceInclude ( $id , $definition )
2010-05-06 12:25:53 +01:00
{
2011-01-05 11:13:27 +00:00
$template = " require_once %s; \n " ;
$code = '' ;
if ( null !== $file = $definition -> getFile ()) {
$code .= sprintf ( $template , $this -> dumpValue ( $file ));
}
foreach ( $this -> getInlinedDefinitions ( $definition ) as $definition ) {
if ( null !== $file = $definition -> getFile ()) {
$code .= sprintf ( $template , $this -> dumpValue ( $file ));
}
}
if ( '' !== $code ) {
$code .= " \n " ;
}
return $code ;
}
2011-02-13 18:06:41 +00:00
/**
* Generates the inline definition of a service .
*
2011-03-04 14:26:00 +00:00
* @ param string $id
* @ param Definition $definition
2011-12-13 07:50:54 +00:00
*
2011-02-13 18:06:41 +00:00
* @ return string
*/
2011-03-11 13:50:46 +00:00
private function addServiceInlinedDefinitions ( $id , $definition )
2011-01-05 11:13:27 +00:00
{
$code = '' ;
$variableMap = $this -> definitionVariables ;
2011-01-09 13:57:17 +00:00
$nbOccurrences = new \SplObjectStorage ();
$processed = new \SplObjectStorage ();
$inlinedDefinitions = $this -> getInlinedDefinitions ( $definition );
foreach ( $inlinedDefinitions as $definition ) {
if ( false === $nbOccurrences -> contains ( $definition )) {
$nbOccurrences -> offsetSet ( $definition , 1 );
} else {
$i = $nbOccurrences -> offsetGet ( $definition );
$nbOccurrences -> offsetSet ( $definition , $i + 1 );
}
}
foreach ( $inlinedDefinitions as $sDefinition ) {
if ( $processed -> contains ( $sDefinition )) {
continue ;
}
$processed -> offsetSet ( $sDefinition );
2011-01-05 11:13:27 +00:00
$class = $this -> dumpValue ( $sDefinition -> getClass ());
2011-03-04 14:26:00 +00:00
if ( $nbOccurrences -> offsetGet ( $sDefinition ) > 1 || count ( $sDefinition -> getMethodCalls ()) > 0 || $sDefinition -> getProperties () || null !== $sDefinition -> getConfigurator () || false !== strpos ( $class , '$' )) {
2011-01-05 11:13:27 +00:00
$name = $this -> getNextVariableName ();
$variableMap -> offsetSet ( $sDefinition , new Variable ( $name ));
// a construct like:
// $a = new ServiceA(ServiceB $b); $b = new ServiceB(ServiceA $a);
// this is an indication for a wrong implementation, you can circumvent this problem
// by setting up your service structure like this:
// $b = new ServiceB();
// $a = new ServiceA(ServiceB $b);
// $b->setServiceA(ServiceA $a);
if ( $this -> hasReference ( $id , $sDefinition -> getArguments ())) {
2011-05-25 08:46:30 +01:00
throw new ServiceCircularReferenceException ( $id , array ( $id ));
2011-01-05 11:13:27 +00:00
}
$arguments = array ();
foreach ( $sDefinition -> getArguments () as $argument ) {
$arguments [] = $this -> dumpValue ( $argument );
}
if ( null !== $sDefinition -> getFactoryMethod ()) {
2011-02-02 17:22:27 +00:00
if ( null !== $sDefinition -> getFactoryClass ()) {
$code .= sprintf ( " \$ %s = call_user_func(array(%s, '%s')%s); \n " , $name , $this -> dumpValue ( $sDefinition -> getFactoryClass ()), $sDefinition -> getFactoryMethod (), count ( $arguments ) > 0 ? ', ' . implode ( ', ' , $arguments ) : '' );
} elseif ( null !== $sDefinition -> getFactoryService ()) {
2011-01-05 11:13:27 +00:00
$code .= sprintf ( " \$ %s = %s->%s(%s); \n " , $name , $this -> getServiceCall ( $sDefinition -> getFactoryService ()), $sDefinition -> getFactoryMethod (), implode ( ', ' , $arguments ));
} else {
2011-12-04 23:51:22 +00:00
throw new RuntimeException ( 'Factory service or factory class must be defined in service definition for ' . $id );
2011-01-05 11:13:27 +00:00
}
} elseif ( false !== strpos ( $class , '$' )) {
$code .= sprintf ( " \$ class = %s; \n \$ %s = new \$ class(%s); \n " , $class , $name , implode ( ', ' , $arguments ));
} else {
$code .= sprintf ( " \$ %s = new \\ %s(%s); \n " , $name , substr ( str_replace ( '\\\\' , '\\' , $class ), 1 , - 1 ), implode ( ', ' , $arguments ));
}
2011-03-04 14:26:00 +00:00
if ( ! $this -> hasReference ( $id , $sDefinition -> getMethodCalls ()) && ! $this -> hasReference ( $id , $sDefinition -> getProperties ())) {
2011-01-05 11:13:27 +00:00
$code .= $this -> addServiceMethodCalls ( null , $sDefinition , $name );
2011-03-04 14:26:00 +00:00
$code .= $this -> addServiceProperties ( null , $sDefinition , $name );
2011-01-05 11:13:27 +00:00
$code .= $this -> addServiceConfigurator ( null , $sDefinition , $name );
}
$code .= " \n " ;
}
2010-05-06 12:25:53 +01:00
}
2011-01-05 11:13:27 +00:00
return $code ;
2010-01-04 14:26:20 +00:00
}
2011-02-13 18:06:41 +00:00
/**
* Adds the service return statement .
*
* @ param string $id Service id
2011-03-04 14:26:00 +00:00
* @ param Definition $definition
2011-12-13 07:50:54 +00:00
*
2011-02-13 18:06:41 +00:00
* @ return string
*/
2011-03-11 13:50:46 +00:00
private function addServiceReturn ( $id , $definition )
2010-05-06 12:25:53 +01:00
{
2011-01-05 11:13:27 +00:00
if ( $this -> isSimpleInstance ( $id , $definition )) {
2010-11-24 07:27:22 +00:00
return " } \n " ;
}
2010-01-04 14:26:20 +00:00
2010-11-24 07:27:22 +00:00
return " \n return \$ instance; \n } \n " ;
2010-01-04 14:26:20 +00:00
}
2011-02-13 18:06:41 +00:00
/**
* Generates the service instance .
*
* @ param string $id
2011-03-04 14:26:00 +00:00
* @ param Definition $definition
2011-12-13 07:50:54 +00:00
*
2011-02-13 18:06:41 +00:00
* @ return string
*
2011-12-04 23:51:22 +00:00
* @ throws InvalidArgumentException
* @ throws RuntimeException
2011-02-13 18:06:41 +00:00
*/
2011-03-11 13:50:46 +00:00
private function addServiceInstance ( $id , $definition )
2010-01-04 14:26:20 +00:00
{
2010-05-06 12:25:53 +01:00
$class = $this -> dumpValue ( $definition -> getClass ());
2010-03-01 17:37:22 +00:00
2010-07-16 19:59:38 +01:00
if ( 0 === strpos ( $class , " ' " ) && ! preg_match ( '/^\'[a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*(\\\{2}[a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*)*\'$/' , $class )) {
2011-12-04 23:51:22 +00:00
throw new InvalidArgumentException ( sprintf ( '"%s" is not a valid class name for the "%s" service.' , $class , $id ));
2010-07-16 16:45:10 +01:00
}
2010-05-06 12:25:53 +01:00
$arguments = array ();
2010-05-07 15:09:11 +01:00
foreach ( $definition -> getArguments () as $value ) {
2010-05-06 12:25:53 +01:00
$arguments [] = $this -> dumpValue ( $value );
}
2010-03-01 17:37:22 +00:00
2011-01-05 11:13:27 +00:00
$simple = $this -> isSimpleInstance ( $id , $definition );
2010-11-24 07:27:22 +00:00
$instantiation = '' ;
2011-01-17 22:28:59 +00:00
if ( ContainerInterface :: SCOPE_CONTAINER === $definition -> getScope ()) {
2010-11-24 07:27:22 +00:00
$instantiation = " \$ this->services[' $id '] = " . ( $simple ? '' : '$instance' );
2011-12-18 13:42:59 +00:00
} elseif ( ContainerInterface :: SCOPE_PROTOTYPE !== $scope = $definition -> getScope ()) {
2011-01-17 22:28:59 +00:00
$instantiation = " \$ this->services[' $id '] = \$ this->scopedServices[' $scope '][' $id '] = " . ( $simple ? '' : '$instance' );
2010-11-24 07:27:22 +00:00
} elseif ( ! $simple ) {
$instantiation = '$instance' ;
}
$return = '' ;
if ( $simple ) {
$return = 'return ' ;
2010-11-23 21:43:09 +00:00
} else {
2010-11-24 07:27:22 +00:00
$instantiation .= ' = ' ;
2010-11-23 21:43:09 +00:00
}
2010-07-05 08:47:14 +01:00
if ( null !== $definition -> getFactoryMethod ()) {
2011-02-02 17:22:27 +00:00
if ( null !== $definition -> getFactoryClass ()) {
$code = sprintf ( " $return { $instantiation } call_user_func(array(%s, '%s')%s); \n " , $this -> dumpValue ( $definition -> getFactoryClass ()), $definition -> getFactoryMethod (), $arguments ? ', ' . implode ( ', ' , $arguments ) : '' );
} elseif ( null !== $definition -> getFactoryService ()) {
2010-11-24 07:27:22 +00:00
$code = sprintf ( " $return { $instantiation } %s->%s(%s); \n " , $this -> getServiceCall ( $definition -> getFactoryService ()), $definition -> getFactoryMethod (), implode ( ', ' , $arguments ));
2010-07-03 23:35:39 +01:00
} else {
2011-12-04 23:51:22 +00:00
throw new RuntimeException ( 'Factory method requires a factory service or factory class in service definition for ' . $id );
2010-07-03 23:35:39 +01:00
}
2010-11-23 21:43:09 +00:00
} elseif ( false !== strpos ( $class , '$' )) {
2010-11-24 07:27:22 +00:00
$code = sprintf ( " \$ class = %s; \n $return { $instantiation } new \$ class(%s); \n " , $class , implode ( ', ' , $arguments ));
2010-05-07 15:09:11 +01:00
} else {
2010-11-24 07:27:22 +00:00
$code = sprintf ( " $return { $instantiation } new \\ %s(%s); \n " , substr ( str_replace ( '\\\\' , '\\' , $class ), 1 , - 1 ), implode ( ', ' , $arguments ));
2010-05-06 12:25:53 +01:00
}
2010-01-04 14:26:20 +00:00
2011-01-05 11:13:27 +00:00
if ( ! $simple ) {
$code .= " \n " ;
}
2010-05-06 12:25:53 +01:00
return $code ;
2010-01-04 14:26:20 +00:00
}
2011-02-13 18:06:41 +00:00
/**
* Checks if the definition is a simple instance .
*
2011-03-04 14:26:00 +00:00
* @ param string $id
* @ param Definition $definition
2011-12-13 07:50:54 +00:00
*
2011-04-27 06:25:26 +01:00
* @ return Boolean
2011-02-13 18:06:41 +00:00
*/
2011-03-11 13:50:46 +00:00
private function isSimpleInstance ( $id , $definition )
2011-01-05 11:13:27 +00:00
{
foreach ( array_merge ( array ( $definition ), $this -> getInlinedDefinitions ( $definition )) as $sDefinition ) {
if ( $definition !== $sDefinition && ! $this -> hasReference ( $id , $sDefinition -> getMethodCalls ())) {
continue ;
}
2011-03-04 14:26:00 +00:00
if ( $sDefinition -> getMethodCalls () || $sDefinition -> getProperties () || $sDefinition -> getConfigurator ()) {
2011-01-05 11:13:27 +00:00
return false ;
}
}
return true ;
}
2011-02-13 18:06:41 +00:00
/**
* Adds method calls to a service definition .
*
2011-03-04 14:26:00 +00:00
* @ param string $id
* @ param Definition $definition
* @ param string $variableName
2011-12-13 07:50:54 +00:00
*
2011-02-13 18:06:41 +00:00
* @ return string
*/
2011-03-11 13:50:46 +00:00
private function addServiceMethodCalls ( $id , $definition , $variableName = 'instance' )
2010-01-04 14:26:20 +00:00
{
2010-05-06 12:25:53 +01:00
$calls = '' ;
2010-05-07 15:09:11 +01:00
foreach ( $definition -> getMethodCalls () as $call ) {
2010-05-06 12:25:53 +01:00
$arguments = array ();
2010-05-07 15:09:11 +01:00
foreach ( $call [ 1 ] as $value ) {
2010-05-06 12:25:53 +01:00
$arguments [] = $this -> dumpValue ( $value );
}
2010-01-04 14:26:20 +00:00
2011-01-05 11:13:27 +00:00
$calls .= $this -> wrapServiceConditionals ( $call [ 1 ], sprintf ( " \$ %s->%s(%s); \n " , $variableName , $call [ 0 ], implode ( ', ' , $arguments )));
2010-05-06 12:25:53 +01:00
}
2010-01-04 14:26:20 +00:00
2010-05-06 12:25:53 +01:00
return $calls ;
}
2010-01-04 14:26:20 +00:00
2011-03-11 13:50:46 +00:00
private function addServiceProperties ( $id , $definition , $variableName = 'instance' )
2011-03-04 14:26:00 +00:00
{
$code = '' ;
foreach ( $definition -> getProperties () as $name => $value ) {
2011-06-27 07:28:54 +01:00
$code .= sprintf ( " \$ %s->%s = %s; \n " , $variableName , $name , $this -> dumpValue ( $value ));
2011-03-04 14:26:00 +00:00
}
return $code ;
}
2011-02-13 18:06:41 +00:00
/**
* Generates the inline definition setup .
*
2011-03-04 14:26:00 +00:00
* @ param string $id
* @ param Definition $definition
2011-02-13 18:06:41 +00:00
* @ return string
*/
2011-03-11 13:50:46 +00:00
private function addServiceInlinedDefinitionsSetup ( $id , $definition )
2011-01-05 11:13:27 +00:00
{
$this -> referenceVariables [ $id ] = new Variable ( 'instance' );
$code = '' ;
2011-01-09 13:57:17 +00:00
$processed = new \SplObjectStorage ();
2011-01-05 11:13:27 +00:00
foreach ( $this -> getInlinedDefinitions ( $definition ) as $iDefinition ) {
2011-01-09 13:57:17 +00:00
if ( $processed -> contains ( $iDefinition )) {
continue ;
}
$processed -> offsetSet ( $iDefinition );
2011-01-05 11:13:27 +00:00
if ( ! $this -> hasReference ( $id , $iDefinition -> getMethodCalls ())) {
continue ;
}
if ( $iDefinition -> getMethodCalls ()) {
$code .= $this -> addServiceMethodCalls ( null , $iDefinition , ( string ) $this -> definitionVariables -> offsetGet ( $iDefinition ));
}
if ( $iDefinition -> getConfigurator ()) {
$code .= $this -> addServiceConfigurator ( null , $iDefinition , ( string ) $this -> definitionVariables -> offsetGet ( $iDefinition ));
}
}
if ( '' !== $code ) {
$code .= " \n " ;
}
return $code ;
}
2011-02-13 18:06:41 +00:00
/**
* Adds configurator definition
*
2011-03-04 14:26:00 +00:00
* @ param string $id
* @ param Definition $definition
* @ param string $variableName
2011-12-13 07:50:54 +00:00
*
2011-02-13 18:06:41 +00:00
* @ return string
*/
2011-03-11 13:50:46 +00:00
private function addServiceConfigurator ( $id , $definition , $variableName = 'instance' )
2010-01-04 14:26:20 +00:00
{
2010-05-07 15:09:11 +01:00
if ( ! $callable = $definition -> getConfigurator ()) {
2010-05-06 12:25:53 +01:00
return '' ;
}
2010-01-04 14:26:20 +00:00
2010-05-07 15:09:11 +01:00
if ( is_array ( $callable )) {
2010-05-08 14:32:30 +01:00
if ( is_object ( $callable [ 0 ]) && $callable [ 0 ] instanceof Reference ) {
2011-01-05 11:13:27 +00:00
return sprintf ( " %s->%s( \$ %s); \n " , $this -> getServiceCall (( string ) $callable [ 0 ]), $callable [ 1 ], $variableName );
2010-05-06 12:25:53 +01:00
}
2011-02-27 17:27:22 +00:00
return sprintf ( " call_user_func(array(%s, '%s'), \$ %s); \n " , $this -> dumpValue ( $callable [ 0 ]), $callable [ 1 ], $variableName );
2010-05-06 12:25:53 +01:00
}
2011-02-27 17:27:22 +00:00
return sprintf ( " %s( \$ %s); \n " , $callable , $variableName );
2010-01-04 14:26:20 +00:00
}
2011-02-13 18:06:41 +00:00
/**
* Adds a service
*
2011-03-04 14:26:00 +00:00
* @ param string $id
* @ param Definition $definition
2011-12-13 07:50:54 +00:00
*
2011-02-13 18:06:41 +00:00
* @ return string
*/
2011-03-11 13:50:46 +00:00
private function addService ( $id , $definition )
2010-05-06 12:25:53 +01:00
{
$name = Container :: camelize ( $id );
2011-01-05 11:13:27 +00:00
$this -> definitionVariables = new \SplObjectStorage ();
$this -> referenceVariables = array ();
$this -> variableCount = 0 ;
2010-07-04 17:56:48 +01:00
$return = '' ;
2011-01-23 11:06:23 +00:00
if ( $definition -> isSynthetic ()) {
2011-12-05 18:04:50 +00:00
$return = sprintf ( '@throws RuntimeException always since this service is expected to be injected dynamically' );
2011-02-02 17:22:27 +00:00
} elseif ( $class = $definition -> getClass ()) {
2010-07-04 17:56:48 +01:00
$return = sprintf ( " @return %s A %s instance. " , 0 === strpos ( $class , '%' ) ? 'Object' : $class , $class );
2011-02-02 17:22:27 +00:00
} elseif ( $definition -> getFactoryClass ()) {
$return = sprintf ( '@return Object An instance returned by %s::%s().' , $definition -> getFactoryClass (), $definition -> getFactoryMethod ());
2010-07-04 17:56:48 +01:00
} elseif ( $definition -> getFactoryService ()) {
$return = sprintf ( '@return Object An instance returned by %s::%s().' , $definition -> getFactoryService (), $definition -> getFactoryMethod ());
}
2010-01-04 14:26:20 +00:00
2010-05-06 12:25:53 +01:00
$doc = '' ;
2011-01-17 22:28:59 +00:00
if ( ContainerInterface :: SCOPE_PROTOTYPE !== $definition -> getScope ()) {
2011-01-05 11:13:27 +00:00
$doc .= <<< EOF
2010-01-04 14:26:20 +00:00
2010-05-06 12:25:53 +01:00
*
* This service is shared .
* This method always returns the same instance of the service .
2010-01-04 14:26:20 +00:00
EOF ;
2010-05-06 12:25:53 +01:00
}
2010-01-04 14:26:20 +00:00
2011-01-05 11:13:27 +00:00
if ( ! $definition -> isPublic ()) {
$doc .= <<< EOF
*
* This service is private .
* If you want to be able to request this service from the container directly ,
* make it public , otherwise you might end up with broken code .
EOF ;
}
2010-05-06 12:25:53 +01:00
$code = <<< EOF
2010-01-04 14:26:20 +00:00
2010-05-06 12:25:53 +01:00
/**
* Gets the '$id' service . $doc
*
2010-07-04 17:56:48 +01:00
* $return
2010-05-06 12:25:53 +01:00
*/
protected function get { $name } Service ()
{
2010-01-04 14:26:20 +00:00
2010-05-06 12:25:53 +01:00
EOF ;
2010-01-04 14:26:20 +00:00
2011-01-17 22:28:59 +00:00
$scope = $definition -> getScope ();
if ( ContainerInterface :: SCOPE_CONTAINER !== $scope && ContainerInterface :: SCOPE_PROTOTYPE !== $scope ) {
$code .= <<< EOF
if ( ! isset ( \ $this -> scopedServices [ '$scope' ])) {
2011-03-14 20:12:42 +00:00
throw new InactiveScopeException ( '$id' , '$scope' );
2011-01-17 22:28:59 +00:00
}
EOF ;
}
2011-01-23 11:06:23 +00:00
if ( $definition -> isSynthetic ()) {
2011-12-05 18:04:50 +00:00
$code .= sprintf ( " throw new RuntimeException('You have requested a synthetic service ( \" %s \" ). The DIC does not know how to construct this service.'); \n } \n " , $id );
2011-01-23 11:06:23 +00:00
} else {
$code .=
$this -> addServiceInclude ( $id , $definition ) .
$this -> addServiceLocalTempVariables ( $id , $definition ) .
$this -> addServiceInlinedDefinitions ( $id , $definition ) .
$this -> addServiceInstance ( $id , $definition ) .
$this -> addServiceInlinedDefinitionsSetup ( $id , $definition ) .
$this -> addServiceMethodCalls ( $id , $definition ) .
2011-03-04 14:26:00 +00:00
$this -> addServiceProperties ( $id , $definition ) .
2011-01-23 11:06:23 +00:00
$this -> addServiceConfigurator ( $id , $definition ) .
$this -> addServiceReturn ( $id , $definition )
;
}
2010-05-06 12:25:53 +01:00
2011-01-05 11:13:27 +00:00
$this -> definitionVariables = null ;
$this -> referenceVariables = null ;
2010-05-06 12:25:53 +01:00
return $code ;
2010-01-04 14:26:20 +00:00
}
2011-02-13 18:06:41 +00:00
/**
* Adds a service alias .
*
2011-03-04 14:26:00 +00:00
* @ param string $alias
* @ param string $id
2011-12-13 07:50:54 +00:00
*
2011-02-13 18:06:41 +00:00
* @ return string
*/
2011-03-11 13:50:46 +00:00
private function addServiceAlias ( $alias , $id )
2010-05-06 12:25:53 +01:00
{
$name = Container :: camelize ( $alias );
$type = 'Object' ;
2010-01-04 14:26:20 +00:00
2010-05-07 15:09:11 +01:00
if ( $this -> container -> hasDefinition ( $id )) {
2010-05-06 12:25:53 +01:00
$class = $this -> container -> getDefinition ( $id ) -> getClass ();
$type = 0 === strpos ( $class , '%' ) ? 'Object' : $class ;
}
2010-01-04 14:26:20 +00:00
2010-05-06 12:25:53 +01:00
return <<< EOF
2010-01-04 14:26:20 +00:00
2010-05-06 12:25:53 +01:00
/**
* Gets the $alias service alias .
*
* @ return $type An instance of the $id service
*/
protected function get { $name } Service ()
2010-01-04 14:26:20 +00:00
{
2010-05-06 12:25:53 +01:00
return { $this -> getServiceCall ( $id )};
2010-01-04 14:26:20 +00:00
}
2010-05-06 12:25:53 +01:00
EOF ;
2010-01-04 14:26:20 +00:00
}
2011-02-13 18:06:41 +00:00
/**
* Adds multiple services
*
* @ return string
*/
2011-03-11 13:50:46 +00:00
private function addServices ()
2010-02-09 08:45:23 +00:00
{
2011-01-05 11:13:27 +00:00
$publicServices = $privateServices = $aliasServices = '' ;
2011-01-26 23:14:31 +00:00
$definitions = $this -> container -> getDefinitions ();
ksort ( $definitions );
foreach ( $definitions as $id => $definition ) {
2011-01-05 11:13:27 +00:00
if ( $definition -> isPublic ()) {
$publicServices .= $this -> addService ( $id , $definition );
} else {
$privateServices .= $this -> addService ( $id , $definition );
}
2010-02-09 08:45:23 +00:00
}
2011-01-26 23:14:31 +00:00
$aliases = $this -> container -> getAliases ();
ksort ( $aliases );
foreach ( $aliases as $alias => $id ) {
2011-01-05 11:13:27 +00:00
$aliasServices .= $this -> addServiceAlias ( $alias , $id );
2010-05-06 12:25:53 +01:00
}
2010-02-09 08:45:23 +00:00
2011-01-05 11:13:27 +00:00
return $publicServices . $aliasServices . $privateServices ;
2010-05-06 12:25:53 +01:00
}
2010-02-09 08:45:23 +00:00
2011-02-13 18:06:41 +00:00
/**
* Adds the class headers .
*
* @ param string $class Class name
* @ param string $baseClass The name of the base class
2011-12-13 07:50:54 +00:00
*
2011-02-13 18:06:41 +00:00
* @ return string
*/
2011-03-11 13:50:46 +00:00
private function startClass ( $class , $baseClass )
2010-01-04 14:26:20 +00:00
{
2011-07-16 14:52:02 +01:00
$bagClass = $this -> container -> isFrozen () ? 'use Symfony\Component\DependencyInjection\ParameterBag\FrozenParameterBag;' : 'use Symfony\Component\DependencyInjection\ParameterBag\\ParameterBag;' ;
2010-06-27 17:28:29 +01:00
2010-05-06 12:25:53 +01:00
return <<< EOF
2010-01-04 14:26:20 +00:00
< ? php
2010-08-20 22:09:55 +01:00
use Symfony\Component\DependencyInjection\ContainerInterface ;
use Symfony\Component\DependencyInjection\Container ;
2011-03-14 20:12:42 +00:00
use Symfony\Component\DependencyInjection\Exception\InactiveScopeException ;
2011-12-05 18:04:50 +00:00
use Symfony\Component\DependencyInjection\Exception\InvalidArgumentException ;
use Symfony\Component\DependencyInjection\Exception\LogicException ;
use Symfony\Component\DependencyInjection\Exception\RuntimeException ;
2010-08-20 22:09:55 +01:00
use Symfony\Component\DependencyInjection\Reference ;
use Symfony\Component\DependencyInjection\Parameter ;
2011-01-30 14:06:45 +00:00
$bagClass
2010-01-04 14:26:20 +00:00
/**
* $class
*
* This class has been auto - generated
2010-07-05 10:08:27 +01:00
* by the Symfony Dependency Injection Component .
2010-01-04 14:26:20 +00:00
*/
2011-01-17 10:40:04 +00:00
class $ class extends $baseClass
2010-01-04 14:26:20 +00:00
{
EOF ;
2010-05-06 12:25:53 +01:00
}
2010-01-04 14:26:20 +00:00
2011-02-13 18:06:41 +00:00
/**
* Adds the constructor .
*
* @ return string
*/
2011-03-11 13:50:46 +00:00
private function addConstructor ()
2010-01-04 14:26:20 +00:00
{
2012-01-06 20:20:08 +00:00
$arguments = $this -> container -> getParameterBag () -> all () ? 'new ParameterBag($this->getDefaultParameters())' : null ;
2011-01-17 22:28:59 +00:00
$code = <<< EOF
2010-01-04 14:26:20 +00:00
2010-05-06 12:25:53 +01:00
/**
* Constructor .
*/
public function __construct ()
{
2012-01-06 20:20:08 +00:00
parent :: __construct ( $arguments );
2011-01-17 22:28:59 +00:00
EOF ;
if ( count ( $scopes = $this -> container -> getScopes ()) > 0 ) {
$code .= " \n " ;
$code .= " \$ this->scopes = " . $this -> dumpValue ( $scopes ) . " ; \n " ;
$code .= " \$ this->scopeChildren = " . $this -> dumpValue ( $this -> container -> getScopeChildren ()) . " ; \n " ;
}
$code .= <<< EOF
2010-05-06 12:25:53 +01:00
}
2010-01-04 14:26:20 +00:00
2011-01-30 14:06:45 +00:00
EOF ;
return $code ;
}
2011-02-13 18:06:41 +00:00
/**
* Adds the constructor for a frozen container .
*
* @ return string
*/
2011-03-11 13:50:46 +00:00
private function addFrozenConstructor ()
2011-01-30 14:06:45 +00:00
{
$code = <<< EOF
/**
* Constructor .
*/
public function __construct ()
{
\ $this -> parameters = \ $this -> getDefaultParameters ();
\ $this -> services =
\ $this -> scopedServices =
\ $this -> scopeStacks = array ();
\ $this -> set ( 'service_container' , \ $this );
EOF ;
$code .= " \n " ;
if ( count ( $scopes = $this -> container -> getScopes ()) > 0 ) {
$code .= " \$ this->scopes = " . $this -> dumpValue ( $scopes ) . " ; \n " ;
$code .= " \$ this->scopeChildren = " . $this -> dumpValue ( $this -> container -> getScopeChildren ()) . " ; \n " ;
} else {
$code .= " \$ this->scopes = array(); \n " ;
$code .= " \$ this->scopeChildren = array(); \n " ;
}
$code .= <<< EOF
}
2010-01-04 14:26:20 +00:00
EOF ;
2011-01-17 22:28:59 +00:00
return $code ;
2010-01-04 14:26:20 +00:00
}
2011-02-13 18:06:41 +00:00
/**
* Adds default parameters method .
*
* @ return string
*/
2011-03-11 13:50:46 +00:00
private function addDefaultParametersMethod ()
2010-05-06 12:25:53 +01:00
{
2010-06-27 17:28:29 +01:00
if ( ! $this -> container -> getParameterBag () -> all ()) {
2010-05-06 12:25:53 +01:00
return '' ;
}
2010-01-04 14:26:20 +00:00
2010-06-27 17:28:29 +01:00
$parameters = $this -> exportParameters ( $this -> container -> getParameterBag () -> all ());
2010-01-04 14:26:20 +00:00
2011-01-30 14:06:45 +00:00
$code = '' ;
if ( $this -> container -> isFrozen ()) {
$code .= <<< EOF
/**
* { @ inheritdoc }
*/
public function getParameter ( \ $name )
{
\ $name = strtolower ( \ $name );
if ( ! array_key_exists ( \ $name , \ $this -> parameters )) {
2011-12-05 18:04:50 +00:00
throw new InvalidArgumentException ( sprintf ( 'The parameter "%s" must be defined.' , \ $name ));
2011-01-30 14:06:45 +00:00
}
return \ $this -> parameters [ \ $name ];
}
/**
* { @ inheritdoc }
*/
public function hasParameter ( \ $name )
{
return array_key_exists ( strtolower ( \ $name ), \ $this -> parameters );
}
/**
* { @ inheritdoc }
*/
public function setParameter ( \ $name , \ $value )
{
2011-12-05 18:04:50 +00:00
throw new LogicException ( 'Impossible to call set() on a frozen ParameterBag.' );
2011-01-30 14:06:45 +00:00
}
2011-07-16 14:52:02 +01:00
/**
* { @ inheritDoc }
*/
public function getParameterBag ()
{
if ( null === \ $this -> parameterBag ) {
2011-07-16 15:13:26 +01:00
\ $this -> parameterBag = new FrozenParameterBag ( \ $this -> parameters );
2011-07-16 14:52:02 +01:00
}
return \ $this -> parameterBag ;
}
2011-01-30 14:06:45 +00:00
EOF ;
}
$code .= <<< EOF
2010-01-04 14:26:20 +00:00
2010-05-06 12:25:53 +01:00
/**
* Gets the default parameters .
*
* @ return array An array of the default parameters
*/
protected function getDefaultParameters ()
2010-01-04 14:26:20 +00:00
{
2010-05-06 12:25:53 +01:00
return $parameters ;
2010-01-04 14:26:20 +00:00
}
EOF ;
2011-01-30 14:06:45 +00:00
return $code ;
2010-01-04 14:26:20 +00:00
}
2011-02-13 18:06:41 +00:00
/**
* Exports parameters .
*
2011-03-21 10:28:38 +00:00
* @ param array $parameters
2011-05-13 11:52:44 +01:00
* @ param string $path
2011-03-04 14:26:00 +00:00
* @ param integer $indent
2011-12-13 07:50:54 +00:00
*
2011-02-13 18:06:41 +00:00
* @ return string
*/
2011-05-13 11:52:44 +01:00
private function exportParameters ( $parameters , $path = '' , $indent = 12 )
2010-01-04 14:26:20 +00:00
{
2010-05-06 12:25:53 +01:00
$php = array ();
2010-05-07 15:09:11 +01:00
foreach ( $parameters as $key => $value ) {
2010-05-08 14:32:30 +01:00
if ( is_array ( $value )) {
2011-05-13 11:52:44 +01:00
$value = $this -> exportParameters ( $value , $path . '/' . $key , $indent + 4 );
2011-01-05 11:13:27 +00:00
} elseif ( $value instanceof Variable ) {
2011-12-04 23:51:22 +00:00
throw new InvalidArgumentException ( sprintf ( 'You cannot dump a container with parameters that contain variable references. Variable "%s" found in "%s".' , $value , $path . '/' . $key ));
2011-01-05 11:13:27 +00:00
} elseif ( $value instanceof Definition ) {
2011-12-04 23:51:22 +00:00
throw new InvalidArgumentException ( sprintf ( 'You cannot dump a container with parameters that contain service definitions. Definition for "%s" found in "%s".' , $value -> getClass (), $path . '/' . $key ));
2010-05-07 15:09:11 +01:00
} elseif ( $value instanceof Reference ) {
2011-12-04 23:51:22 +00:00
throw new InvalidArgumentException ( sprintf ( 'You cannot dump a container with parameters that contain references to other services (reference to service "%s" found in "%s").' , $value , $path . '/' . $key ));
2010-05-07 15:09:11 +01:00
} else {
2010-05-06 12:25:53 +01:00
$value = var_export ( $value , true );
}
$php [] = sprintf ( '%s%s => %s,' , str_repeat ( ' ' , $indent ), var_export ( $key , true ), $value );
}
2010-01-04 14:26:20 +00:00
2010-05-06 12:25:53 +01:00
return sprintf ( " array( \n %s \n %s) " , implode ( " \n " , $php ), str_repeat ( ' ' , $indent - 4 ));
}
2010-01-04 14:26:20 +00:00
2011-02-13 18:06:41 +00:00
/**
* Ends the class definition .
*
2011-06-04 16:30:56 +01:00
* @ return string
2011-02-13 18:06:41 +00:00
*/
2011-03-11 13:50:46 +00:00
private function endClass ()
2010-01-04 14:26:20 +00:00
{
2010-05-06 12:25:53 +01:00
return <<< EOF
}
2010-01-04 14:26:20 +00:00
2010-05-06 12:25:53 +01:00
EOF ;
2010-01-04 14:26:20 +00:00
}
2010-05-06 12:25:53 +01:00
2011-02-13 18:06:41 +00:00
/**
* Wraps the service conditionals .
*
2011-03-04 14:26:00 +00:00
* @ param string $value
* @ param string $code
2011-12-13 07:50:54 +00:00
*
2011-02-13 18:06:41 +00:00
* @ return string
*/
2011-03-11 13:50:46 +00:00
private function wrapServiceConditionals ( $value , $code )
2010-01-04 14:26:20 +00:00
{
2010-07-15 14:11:33 +01:00
if ( ! $services = ContainerBuilder :: getServiceConditionals ( $value )) {
2010-05-06 12:25:53 +01:00
return $code ;
}
2010-01-04 14:26:20 +00:00
2010-05-06 12:25:53 +01:00
$conditions = array ();
2010-05-07 15:09:11 +01:00
foreach ( $services as $service ) {
2010-06-27 17:28:29 +01:00
$conditions [] = sprintf ( " \$ this->has('%s') " , $service );
2010-05-06 12:25:53 +01:00
}
2010-01-04 14:26:20 +00:00
2010-05-06 12:25:53 +01:00
// re-indent the wrapped code
$code = implode ( " \n " , array_map ( function ( $line ) { return $line ? ' ' . $line : $line ; }, explode ( " \n " , $code )));
2010-01-04 14:26:20 +00:00
2010-05-07 15:09:11 +01:00
return sprintf ( " if (%s) { \n %s } \n " , implode ( ' && ' , $conditions ), $code );
2010-01-04 14:26:20 +00:00
}
2011-02-13 18:06:41 +00:00
/**
* Builds service calls from arguments
*
2011-04-23 16:05:44 +01:00
* @ param array $arguments
2011-12-13 07:50:54 +00:00
* @ param string & $calls By reference
* @ param string & $behavior By reference
2011-02-13 18:06:41 +00:00
*/
2011-03-11 13:50:46 +00:00
private function getServiceCallsFromArguments ( array $arguments , array & $calls , array & $behavior )
2011-01-05 11:13:27 +00:00
{
foreach ( $arguments as $argument ) {
if ( is_array ( $argument )) {
$this -> getServiceCallsFromArguments ( $argument , $calls , $behavior );
2011-12-18 13:42:59 +00:00
} elseif ( $argument instanceof Reference ) {
2011-01-05 11:13:27 +00:00
$id = ( string ) $argument ;
if ( ! isset ( $calls [ $id ])) {
$calls [ $id ] = 0 ;
}
if ( ! isset ( $behavior [ $id ])) {
$behavior [ $id ] = $argument -> getInvalidBehavior ();
2011-12-18 13:42:59 +00:00
} elseif ( ContainerInterface :: EXCEPTION_ON_INVALID_REFERENCE !== $behavior [ $id ]) {
2011-01-05 11:13:27 +00:00
$behavior [ $id ] = $argument -> getInvalidBehavior ();
}
$calls [ $id ] += 1 ;
}
}
}
2011-02-13 18:06:41 +00:00
/**
* Returns the inline definition
*
2011-03-04 14:26:00 +00:00
* @ param Definition $definition
2011-12-13 07:50:54 +00:00
*
2011-03-21 10:28:38 +00:00
* @ return array
2011-02-13 18:06:41 +00:00
*/
2011-03-11 13:50:46 +00:00
private function getInlinedDefinitions ( Definition $definition )
2011-01-05 11:13:27 +00:00
{
if ( false === $this -> inlinedDefinitions -> contains ( $definition )) {
2011-03-04 14:26:00 +00:00
$definitions = array_merge (
$this -> getDefinitionsFromArguments ( $definition -> getArguments ()),
$this -> getDefinitionsFromArguments ( $definition -> getMethodCalls ()),
$this -> getDefinitionsFromArguments ( $definition -> getProperties ())
);
2011-01-05 11:13:27 +00:00
$this -> inlinedDefinitions -> offsetSet ( $definition , $definitions );
return $definitions ;
}
return $this -> inlinedDefinitions -> offsetGet ( $definition );
}
2011-02-13 18:06:41 +00:00
/**
* Gets the definition from arguments
*
2011-03-04 14:26:00 +00:00
* @ param array $arguments
2011-12-13 07:50:54 +00:00
*
2011-02-13 18:06:41 +00:00
* @ return array
*/
2011-03-11 13:50:46 +00:00
private function getDefinitionsFromArguments ( array $arguments )
2011-01-05 11:13:27 +00:00
{
$definitions = array ();
foreach ( $arguments as $argument ) {
if ( is_array ( $argument )) {
$definitions = array_merge ( $definitions , $this -> getDefinitionsFromArguments ( $argument ));
2011-12-18 13:42:59 +00:00
} elseif ( $argument instanceof Definition ) {
2011-01-05 11:13:27 +00:00
$definitions = array_merge (
$definitions ,
$this -> getInlinedDefinitions ( $argument ),
array ( $argument )
);
}
}
return $definitions ;
}
2011-02-13 18:06:41 +00:00
/**
* Checks if a service id has a reference
*
2011-03-04 14:26:00 +00:00
* @ param string $id
* @ param array $arguments
2011-12-13 07:50:54 +00:00
*
2011-04-27 06:25:26 +01:00
* @ return Boolean
2011-02-13 18:06:41 +00:00
*/
2011-03-11 13:50:46 +00:00
private function hasReference ( $id , array $arguments )
2011-01-05 11:13:27 +00:00
{
foreach ( $arguments as $argument ) {
if ( is_array ( $argument )) {
if ( $this -> hasReference ( $id , $argument )) {
return true ;
}
2011-12-18 13:42:59 +00:00
} elseif ( $argument instanceof Reference ) {
2011-01-05 11:13:27 +00:00
if ( $id === ( string ) $argument ) {
return true ;
}
}
}
return false ;
}
2011-02-13 18:06:41 +00:00
/**
* Dumps values .
*
2011-03-21 10:28:38 +00:00
* @ param array $value
2011-04-27 06:25:26 +01:00
* @ param Boolean $interpolate
2011-12-13 07:50:54 +00:00
*
2011-02-13 18:06:41 +00:00
* @ return string
*/
2011-03-11 13:50:46 +00:00
private function dumpValue ( $value , $interpolate = true )
2010-01-04 14:26:20 +00:00
{
2010-05-07 15:09:11 +01:00
if ( is_array ( $value )) {
2010-05-06 12:25:53 +01:00
$code = array ();
2010-05-07 15:09:11 +01:00
foreach ( $value as $k => $v ) {
2010-06-27 17:28:29 +01:00
$code [] = sprintf ( '%s => %s' , $this -> dumpValue ( $k , $interpolate ), $this -> dumpValue ( $v , $interpolate ));
2010-05-06 12:25:53 +01:00
}
2010-01-04 14:26:20 +00:00
2010-05-06 12:25:53 +01:00
return sprintf ( 'array(%s)' , implode ( ', ' , $code ));
2011-01-05 11:13:27 +00:00
} elseif ( is_object ( $value ) && $value instanceof Definition ) {
if ( null !== $this -> definitionVariables && $this -> definitionVariables -> contains ( $value )) {
return $this -> dumpValue ( $this -> definitionVariables -> offsetGet ( $value ), $interpolate );
}
if ( count ( $value -> getMethodCalls ()) > 0 ) {
2011-12-04 23:51:22 +00:00
throw new RuntimeException ( 'Cannot dump definitions which have method calls.' );
2011-01-05 11:13:27 +00:00
}
if ( null !== $value -> getConfigurator ()) {
2011-12-04 23:51:22 +00:00
throw new RuntimeException ( 'Cannot dump definitions which have a configurator.' );
2011-01-05 11:13:27 +00:00
}
$arguments = array ();
foreach ( $value -> getArguments () as $argument ) {
$arguments [] = $this -> dumpValue ( $argument );
}
$class = $this -> dumpValue ( $value -> getClass ());
if ( false !== strpos ( $class , '$' )) {
2011-12-04 23:51:22 +00:00
throw new RuntimeException ( 'Cannot dump definitions which have a variable class name.' );
2011-01-05 11:13:27 +00:00
}
if ( null !== $value -> getFactoryMethod ()) {
2011-02-02 17:22:27 +00:00
if ( null !== $value -> getFactoryClass ()) {
return sprintf ( " call_user_func(array(%s, '%s')%s) " , $this -> dumpValue ( $value -> getFactoryClass ()), $value -> getFactoryMethod (), count ( $arguments ) > 0 ? ', ' . implode ( ', ' , $arguments ) : '' );
} elseif ( null !== $value -> getFactoryService ()) {
2011-01-05 11:13:27 +00:00
return sprintf ( " %s->%s(%s) " , $this -> getServiceCall ( $value -> getFactoryService ()), $value -> getFactoryMethod (), implode ( ', ' , $arguments ));
} else {
2011-12-04 23:51:22 +00:00
throw new RuntimeException ( 'Cannot dump definitions which have factory method without factory service or factory class.' );
2011-01-05 11:13:27 +00:00
}
}
return sprintf ( " new \\ %s(%s) " , substr ( str_replace ( '\\\\' , '\\' , $class ), 1 , - 1 ), implode ( ', ' , $arguments ));
} elseif ( is_object ( $value ) && $value instanceof Variable ) {
return '$' . $value ;
2010-05-07 15:09:11 +01:00
} elseif ( is_object ( $value ) && $value instanceof Reference ) {
2011-01-05 11:13:27 +00:00
if ( null !== $this -> referenceVariables && isset ( $this -> referenceVariables [ $id = ( string ) $value ])) {
return $this -> dumpValue ( $this -> referenceVariables [ $id ], $interpolate );
}
2010-05-06 12:25:53 +01:00
return $this -> getServiceCall (( string ) $value , $value );
2010-05-07 15:09:11 +01:00
} elseif ( is_object ( $value ) && $value instanceof Parameter ) {
2010-06-27 17:28:29 +01:00
return $this -> dumpParameter ( $value );
} elseif ( true === $interpolate && is_string ( $value )) {
2010-05-08 14:32:30 +01:00
if ( preg_match ( '/^%([^%]+)%$/' , $value , $match )) {
2011-01-21 01:39:28 +00:00
// we do this to deal with non string values (Boolean, integer, ...)
2010-05-06 12:25:53 +01:00
// the preg_replace_callback converts them to strings
2010-06-27 17:28:29 +01:00
return $this -> dumpParameter ( strtolower ( $match [ 1 ]));
2010-05-07 15:09:11 +01:00
} else {
2010-06-27 17:28:29 +01:00
$that = $this ;
$replaceParameters = function ( $match ) use ( $that )
2010-05-06 12:25:53 +01:00
{
2011-05-26 07:22:16 +01:00
return " '. " . $that -> dumpParameter ( strtolower ( $match [ 2 ])) . " .' " ;
2010-05-06 12:25:53 +01:00
};
$code = str_replace ( '%%' , '%' , preg_replace_callback ( '/(?<!%)(%)([^%]+)\1/' , $replaceParameters , var_export ( $value , true )));
// optimize string
2011-10-18 13:52:35 +01:00
$code = preg_replace ( array ( " /^'' \ ./ " , " / \ .'' $ / " , " /( \ w+)(?:' \ .')/ " , " /(.+)(?: \ .'' \ .)/ " ), array ( '' , '' , '$1' , '$1.' ), $code );
2010-05-06 12:25:53 +01:00
return $code ;
}
2010-05-07 15:09:11 +01:00
} elseif ( is_object ( $value ) || is_resource ( $value )) {
2011-12-04 23:51:22 +00:00
throw new RuntimeException ( 'Unable to dump a service container if a parameter is an object or a resource.' );
2010-05-07 15:09:11 +01:00
} else {
2010-05-06 12:25:53 +01:00
return var_export ( $value , true );
}
2010-01-04 14:26:20 +00:00
}
2010-05-06 12:25:53 +01:00
2011-02-13 18:06:41 +00:00
/**
* Dumps a parameter
*
2011-03-04 14:26:00 +00:00
* @ param string $name
2011-12-13 07:50:54 +00:00
*
2011-02-13 18:06:41 +00:00
* @ return string
*/
2010-06-27 17:28:29 +01:00
public function dumpParameter ( $name )
{
2010-09-03 15:18:04 +01:00
if ( $this -> container -> isFrozen () && $this -> container -> hasParameter ( $name )) {
2010-06-27 17:28:29 +01:00
return $this -> dumpValue ( $this -> container -> getParameter ( $name ), false );
}
return sprintf ( " \$ this->getParameter('%s') " , strtolower ( $name ));
}
2011-02-13 18:06:41 +00:00
/**
* Gets a service call
*
2011-04-23 16:05:44 +01:00
* @ param string $id
2011-03-04 14:26:00 +00:00
* @ param Reference $reference
2011-12-13 07:50:54 +00:00
*
2011-02-13 18:06:41 +00:00
* @ return string
*/
2011-03-11 13:50:46 +00:00
private function getServiceCall ( $id , Reference $reference = null )
2010-01-04 14:26:20 +00:00
{
2010-05-07 15:09:11 +01:00
if ( 'service_container' === $id ) {
2010-05-06 12:25:53 +01:00
return '$this' ;
}
2010-06-27 17:28:29 +01:00
if ( null !== $reference && ContainerInterface :: EXCEPTION_ON_INVALID_REFERENCE !== $reference -> getInvalidBehavior ()) {
return sprintf ( '$this->get(\'%s\', ContainerInterface::NULL_ON_INVALID_REFERENCE)' , $id );
2010-05-07 15:09:11 +01:00
} else {
2010-05-08 14:32:30 +01:00
if ( $this -> container -> hasAlias ( $id )) {
2011-01-07 14:44:29 +00:00
$id = ( string ) $this -> container -> getAlias ( $id );
2010-05-06 12:25:53 +01:00
}
2010-01-21 20:59:59 +00:00
2010-06-27 17:28:29 +01:00
return sprintf ( '$this->get(\'%s\')' , $id );
2010-05-06 12:25:53 +01:00
}
2010-01-04 14:26:20 +00:00
}
2011-01-05 11:13:27 +00:00
/**
* Returns the next name to use
*
* @ return string
*/
2011-03-11 13:50:46 +00:00
private function getNextVariableName ()
2011-01-05 11:13:27 +00:00
{
$firstChars = self :: FIRST_CHARS ;
$firstCharsLength = strlen ( $firstChars );
$nonFirstChars = self :: NON_FIRST_CHARS ;
$nonFirstCharsLength = strlen ( $nonFirstChars );
2011-02-27 19:56:29 +00:00
while ( true ) {
2011-01-05 11:13:27 +00:00
$name = '' ;
$i = $this -> variableCount ;
2011-02-27 19:56:29 +00:00
if ( '' === $name ) {
2011-01-05 11:13:27 +00:00
$name .= $firstChars [ $i % $firstCharsLength ];
$i = intval ( $i / $firstCharsLength );
}
2011-02-27 19:56:29 +00:00
while ( $i > 0 ) {
2011-01-05 11:13:27 +00:00
$i -= 1 ;
$name .= $nonFirstChars [ $i % $nonFirstCharsLength ];
$i = intval ( $i / $nonFirstCharsLength );
}
$this -> variableCount += 1 ;
// check that the name is not reserved
if ( in_array ( $name , $this -> reservedVariables , true )) {
continue ;
}
return $name ;
}
}
2010-01-04 14:26:20 +00:00
}