/**
* Creates a binding type descriptor.
*
* @param BindingType $type The described type.
* @param string|null $description A human-readable description of
* the type.
* @param string[] $parameterDescriptions Human-readable descriptions
* indexed by the type's parameter
* names.
*
* @throws NoSuchParameterException If a description is passed for an unset
* parameter.
*/
public function __construct(BindingType $type, $description = null, array $parameterDescriptions = array())
{
Assert::nullOrStringNotEmpty($description, 'The description must be a non-empty string or null. Got: %s');
Assert::allStringNotEmpty($parameterDescriptions, 'The parameter description must be a non-empty string. Got: %s');
$this->type = $type;
$this->description = $description;
foreach ($parameterDescriptions as $parameterName => $parameterDescription) {
if (!$type->hasParameter($parameterName)) {
throw NoSuchParameterException::forParameterName($parameterName, $type->getName());
}
$this->parameterDescriptions[$parameterName] = $parameterDescription;
}
}
/**
* Creates a new installer descriptor.
*
* @param string $name The installer name.
* @param string $className The fully-qualified class name
* of the installer.
* @param string|null $description The description of the installer.
* @param InstallerParameter[] $parameters The installer parameters.
*/
public function __construct($name, $className, $description = null, array $parameters = array())
{
Assert::stringNotEmpty($name, 'The installer name must be a non-empty string. Got: %s');
Assert::stringNotEmpty($className, 'The installer class must be a non-empty string. Got: %s');
Assert::nullOrStringNotEmpty($description, 'The installer description must be a non-empty string or null. Got: %s');
Assert::allIsInstanceOf($parameters, __NAMESPACE__ . '\\InstallerParameter');
$this->name = $name;
$this->className = $className;
$this->description = $description;
foreach ($parameters as $parameter) {
$this->parameters[$parameter->getName()] = $parameter;
}
}
/**
* Creates the import statement.
*
* @param string $className The fully-qualified imported class name.
* @param string|null $alias If not `null`, the class will be imported
* with the given alias.
*/
public function __construct($className, $alias = null)
{
Assert::stringNotEmpty($className, 'The imported class name must be a non-empty string. Got: %s');
Assert::nullOrStringNotEmpty($className, 'The import alias must be a non-empty string or null. Got: %s');
$pos = strrpos($className, '\\');
if (false === $pos) {
$this->namespaceName = '';
$this->shortClassName = $className;
} else {
$this->namespaceName = substr($className, 0, $pos);
$this->shortClassName = substr($className, $pos + 1);
}
$this->alias = $alias;
}
/**
* {@inheritdoc}
*/
public function refreshFactoryClass($path = null, $className = null)
{
Assert::nullOrStringNotEmpty($path, 'The path to the generated factory file must be a non-empty string or null. Got: %s');
Assert::nullOrStringNotEmpty($className, 'The class name of the generated factory must be a non-empty string or null. Got: %s');
$path = Path::makeAbsolute($path ?: $this->config->get(Config::FACTORY_OUT_FILE), $this->rootDir);
$className = $className ?: $this->config->get(Config::FACTORY_OUT_CLASS);
if (!$this->config->get(Config::FACTORY_AUTO_GENERATE)) {
return;
}
if (!file_exists($path)) {
$this->generateFactoryClass($path, $className);
return;
}
$rootModuleFile = $this->context->getRootModuleFile()->getPath();
if (!file_exists($rootModuleFile)) {
return;
}
// Regenerate file if the configuration has changed and
// auto-generation is enabled
clearstatcache(true, $rootModuleFile);
$lastConfigChange = filemtime($rootModuleFile);
$configFile = $this->context->getConfigFile() ? $this->context->getConfigFile()->getPath() : '';
if (file_exists($configFile)) {
clearstatcache(true, $configFile);
$lastConfigChange = max(filemtime($configFile), $lastConfigChange);
}
clearstatcache(true, $path);
$lastFactoryUpdate = filemtime($path);
if ($lastConfigChange > $lastFactoryUpdate) {
$this->generateFactoryClass($path, $className);
}
}
