/** * Creates a new parameter. * * @param string $name The parameter name. * @param int $flags A bitwise combination of the flag constants * in this class. * @param mixed $defaultValue The parameter's default value. */ public function __construct($name, $flags = self::OPTIONAL, $defaultValue = null) { Assert::stringNotEmpty($name, 'The parameter name must be a non-empty string. Got: %s'); Assert::startsWithLetter($name, 'The parameter name must start with a letter. Got: %s'); Assert::nullOrInteger($flags, 'The parameter "$flags" must be an integer or null. Got: %s'); if ($flags & self::REQUIRED && null !== $defaultValue) { throw new RuntimeException('Required parameters must not have default values.'); } $this->name = $name; $this->flags = $flags; $this->defaultValue = $defaultValue; }
/** * Creates a new type. * * @param string $name The name of the type. * @param BindingParameter[] $parameters The parameters that can be set * during binding. */ public function __construct($name, array $parameters = array()) { Assert::stringNotEmpty($name, 'The type name must be a non-empty string. Got: %s'); Assert::startsWithLetter($name, 'The type name must start with a letter. Got: %s'); Assert::allIsInstanceOf($parameters, 'Puli\\Discovery\\Api\\Binding\\BindingParameter'); $this->name = $name; foreach ($parameters as $parameter) { $this->parameters[$parameter->getName()] = $parameter; } // Sort to facilitate comparison ksort($this->parameters); }
private function assertLongNameValid($longName) { Assert::string($longName, 'The long option name must be a string. Got: %s'); Assert::notEmpty($longName, 'The long option name must not be empty.'); Assert::greaterThan(strlen($longName), 1, sprintf('The long option name must contain more than one character. Got: "%s"', $longName)); Assert::startsWithLetter($longName, 'The long option name must start with a letter.'); Assert::regex($longName, '~^[a-zA-Z0-9\\-]+$~', 'The long option name must contain letters, digits and hyphens only.'); }
private function assertLongAliasValid($alias) { Assert::string($alias, 'An option alias must be a string or null. Got: %s'); Assert::notEmpty($alias, 'An option alias must not be empty.'); Assert::startsWithLetter($alias, 'A long option alias must start with a letter.'); Assert::regex($alias, '~^[a-zA-Z0-9\\-]+$~', 'A long option alias must contain letters, digits and hyphens only.'); }
/** * Creates a new argument. * * @param string $name The argument name * @param int $flags A bitwise combination of the flag constants. * @param string $description A human-readable description of the argument. * @param mixed $defaultValue The default value of the argument (must be * null for the flag {@link self::REQUIRED}). */ public function __construct($name, $flags = 0, $description = null, $defaultValue = null) { Assert::string($name, 'The argument name must be a string. Got: %s'); Assert::notEmpty($name, 'The argument name must not be empty.'); Assert::startsWithLetter($name, 'The argument name must start with a letter.'); Assert::regex($name, '~^[a-zA-Z0-9\\-]+$~', 'The argument name must contain letters, digits and hyphens only.'); Assert::nullOrString($description, 'The argument description must be a string or null. Got: %s'); Assert::nullOrNotEmpty($description, 'The argument description must not be empty.'); $this->assertFlagsValid($flags); $this->addDefaultFlags($flags); $this->name = $name; $this->flags = $flags; $this->description = $description; $this->defaultValue = $this->isMultiValued() ? array() : null; if ($this->isOptional() || null !== $defaultValue) { $this->setDefaultValue($defaultValue); } }
/** * Registers a repository as PHP stream wrapper. * * The resources of the repository can subsequently be accessed with PHP's * file system by prefixing the resource paths with the registered URI * scheme: * * ```php * ResourceStreamWrapper::register('puli', $repo); * * // /app/css/style.css * $contents = file_get_contents('puli:///app/css/style.css'); * ``` * * Instead of passing a repository, you can also pass a callable. The * callable is executed when the repository is accessed for the first time * and should return a valid {@link ResourceRepository} instance. * * @param string $scheme The URI scheme. * @param ResourceRepository|callable $repositoryFactory The repository to use. * * @throws StreamWrapperException If a repository was previously registered * for the same scheme. Call * {@link unregister()} to unregister the * scheme first. */ public static function register($scheme, $repositoryFactory) { if (!$repositoryFactory instanceof ResourceRepository && !is_callable($repositoryFactory)) { throw new InvalidArgumentException(sprintf('The repository factory should be a callable or an instance ' . 'of ResourceRepository. Got: %s', $repositoryFactory)); } Assert::string($scheme, 'The scheme must be a string. Got: %s'); Assert::alnum($scheme, 'The scheme %s should consist of letters and digits only.'); Assert::startsWithLetter($scheme, 'The scheme %s should start with a letter.'); if (isset(self::$repos[$scheme])) { throw new StreamWrapperException(sprintf('The scheme "%s" has already been registered.', $scheme)); } self::$repos[$scheme] = $repositoryFactory; stream_wrapper_register($scheme, __CLASS__); }