PHP Assert::startsWithLetter方法代码示例

 /**
  * 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__);
 }