PHP Inflector::singularize方法代碼示例

 /**
  * Convert an Array to XML
  * @param string $root_node - name of the root node to be converted
  * @param array $data - array to be converted
  * @throws \Exception
  * @return \DOMNode
  */
 protected function convertArrayToXml($root_node, $data = array())
 {
     if (!$this->isValidTagName($root_node)) {
         throw new \Exception('Array to XML Conversion - Illegal character in element name: ' . $root_node);
     }
     $node = $this->xml->createElement($root_node);
     if (is_scalar($data)) {
         $node->appendChild($this->xml->createTextNode($this->bool2str($data)));
     }
     if (is_array($data)) {
         foreach ($data as $key => $value) {
             $this->current_node_name = $root_node;
             $key = is_numeric($key) ? Inflector::singularize($this->current_node_name) : $key;
             $node->appendChild($this->convertArrayToXml($key, $value));
             unset($data[$key]);
         }
     }
     if (is_object($data)) {
         // Catch toString objects, and datetime. Note Closure's will fall into here
         if (method_exists($data, '__toString')) {
             $node->appendChild($this->xml->createTextNode($data->__toString()));
         } elseif ($data instanceof \DateTime) {
             $node->appendChild($this->xml->createTextNode($data->format(\DateTime::ISO8601)));
         } else {
             throw new \Exception('Invalid data type used in Array to XML conversion. Must be object of \\DateTime or implement __toString()');
         }
     }
     return $node;
 }

 /**
  * Execute after types are built.
  */
 public function postBuild()
 {
     $types_build_path = $this->getBuildPath() ? "{$this->getBuildPath()}/types.php" : null;
     if ($types_build_path) {
         $result = [];
         $result[] = '<?php';
         $result[] = '';
         if ($this->getStructure()->getConfig('header_comment')) {
             $result = array_merge($result, explode("\n", $this->getStructure()->getConfig('header_comment')));
             $result[] = '';
         }
         $namespace = $this->getStructure()->getNamespace();
         if ($namespace) {
             $namespace = ltrim($namespace, '\\');
         }
         if ($this->getStructure()->getNamespace()) {
             $result[] = '/**';
             $result[] = ' * @package ' . $this->getStructure()->getNamespace();
             $result[] = ' */';
         }
         $result[] = 'return [';
         foreach ($this->getStructure()->getTypes() as $current_type) {
             $result[] = '    ' . var_export($namespace . '\\' . Inflector::classify(Inflector::singularize($current_type->getName())), true) . ',';
         }
         $result[] = '];';
         $result[] = '';
         $result = implode("\n", $result);
         if (is_file($types_build_path) && file_get_contents($types_build_path) === $result) {
             return;
         } else {
             file_put_contents($types_build_path, $result);
             $this->triggerEvent('on_types_built', [$types_build_path]);
         }
     }
 }

 public function transform($entities)
 {
     foreach ($entities as &$entity) {
         $entity['icon'] = $this->getIcon(Inflector::singularize($entity['name']));
     }
     return $entities;
 }

 public static function arrayToXml(array $data, \SimpleXMLElement $xml, $parentKey = null, $keyFilterCallback = null)
 {
     foreach ($data as $k => $v) {
         if (!is_numeric($k) && is_callable($keyFilterCallback)) {
             $k = call_user_func($keyFilterCallback, $k);
         }
         if (is_array($v)) {
             if (!is_numeric($k)) {
                 self::arrayToXml($v, $xml->addChild($k), $k, $keyFilterCallback);
             } else {
                 self::arrayToXml($v, $xml->addChild(Inflector::singularize($parentKey)), null, $keyFilterCallback);
             }
         } else {
             if (!is_numeric($k)) {
                 $xml->addChildWithCDATA($k, $v);
             } else {
                 if (!is_null($parentKey)) {
                     $xml->addChildWithCDATA(Inflector::singularize($parentKey), $v);
                 } else {
                     throw new \Exception("Array To xml forma error: invalid element name {$k}");
                 }
             }
         }
     }
     return $xml;
 }

 /**
  * @param TypeInterface $type
  */
 public function buildType(TypeInterface $type)
 {
     $class_name = Inflector::classify(Inflector::singularize($type->getName()));
     $base_class_name = 'Base\\' . $class_name;
     $class_build_path = $this->getBuildPath() ? "{$this->getBuildPath()}/{$class_name}.php" : null;
     if ($class_build_path && is_file($class_build_path)) {
         $this->triggerEvent('on_class_build_skipped', [$class_name, $class_build_path]);
         return;
     }
     $result = [];
     $result[] = '<?php';
     $result[] = '';
     if ($this->getStructure()->getConfig('header_comment')) {
         $result = array_merge($result, explode("\n", $this->getStructure()->getConfig('header_comment')));
         $result[] = '';
     }
     if ($this->getStructure()->getNamespace()) {
         $result[] = 'namespace ' . $this->getStructure()->getNamespace() . ';';
         $result[] = '';
         $result[] = '/**';
         $result[] = ' * @package ' . $this->getStructure()->getNamespace();
         $result[] = ' */';
     }
     $result[] = 'class ' . $class_name . ' extends ' . $base_class_name;
     $result[] = '{';
     $result[] = '}';
     $result[] = '';
     $result = implode("\n", $result);
     if ($this->getBuildPath()) {
         file_put_contents($class_build_path, $result);
     } else {
         eval(ltrim($result, '<?php'));
     }
     $this->triggerEvent('on_class_built', [$class_name, $class_build_path]);
 }

 /**
  * Generate the CRUD controller.
  *
  * @param BundleInterface   $bundle           A bundle object
  * @param string            $entity           The entity relative class name
  * @param ClassMetadataInfo $metadata         The entity class metadata
  * @param string            $format           The configuration format (xml, yaml, annotation)
  * @param string            $routePrefix      The route name prefix
  * @param array             $needWriteActions Wether or not to generate write actions
  *
  * @throws \RuntimeException
  */
 public function generate(BundleInterface $bundle, $entity, ClassMetadataInfo $metadata, $format, $routePrefix, $needWriteActions, $forceOverwrite)
 {
     $this->routePrefix = $routePrefix;
     $this->routeNamePrefix = self::getRouteNamePrefix($routePrefix);
     $this->actions = $needWriteActions ? array('index', 'show', 'new', 'edit', 'delete') : array('index', 'show');
     if (count($metadata->identifier) != 1) {
         throw new \RuntimeException('The CRUD generator does not support entity classes with multiple or no primary keys.');
     }
     $this->entity = $entity;
     $this->entitySingularized = lcfirst(Inflector::singularize($entity));
     $this->entityPluralized = lcfirst(Inflector::pluralize($entity));
     $this->bundle = $bundle;
     $this->metadata = $metadata;
     $this->setFormat($format);
     $this->generateControllerClass($forceOverwrite);
     $dir = sprintf('%s/Resources/views/%s', $this->rootDir, str_replace('\\', '/', strtolower($this->entity)));
     if (!file_exists($dir)) {
         $this->filesystem->mkdir($dir, 0777);
     }
     $this->generateIndexView($dir);
     if (in_array('show', $this->actions)) {
         $this->generateShowView($dir);
     }
     if (in_array('new', $this->actions)) {
         $this->generateNewView($dir);
     }
     if (in_array('edit', $this->actions)) {
         $this->generateEditView($dir);
     }
     $this->generateTestClass();
     $this->generateConfiguration();
 }

 /**
  * Executes the command.
  * 
  * @param  \Symfony\Component\Console\Input\InputInterface   $input
  * @param  \Symfony\Component\Console\Output\OutputInterface $output
  * @return object|\Symfony\Component\Console\Output\OutputInterface
  */
 protected function execute(InputInterface $input, OutputInterface $output)
 {
     $config = Configuration::get();
     $templates = str_replace('Commands', 'Templates', __DIR__);
     $contents = [];
     $generator = new ViewGenerator($this->describe);
     $data = ['{name}' => $input->getArgument('name'), '{pluralTitle}' => Inflector::ucwords(str_replace('_', ' ', Inflector::pluralize($input->getArgument('name')))), '{plural}' => Inflector::pluralize($input->getArgument('name')), '{singular}' => Inflector::singularize($input->getArgument('name'))];
     $contents['create'] = $generator->generate($data, $templates, 'create');
     $contents['edit'] = $generator->generate($data, $templates, 'edit');
     $contents['index'] = $generator->generate($data, $templates, 'index');
     $contents['show'] = $generator->generate($data, $templates, 'show');
     $fileName = $config->folders->views . '/' . $data['{plural}'] . '/';
     $layout = $config->folders->views . '/layouts/master.twig';
     if (!$this->filesystem->has($layout)) {
         $template = file_get_contents($templates . '/Views/layout.twig');
         $keywords = ['{application}' => $config->application->name];
         $template = str_replace(array_keys($keywords), array_values($keywords), $template);
         $this->filesystem->write($layout, $template);
     }
     foreach ($contents as $type => $content) {
         $view = $fileName . $type . '.twig';
         if ($this->filesystem->has($view)) {
             if (!$input->getOption('overwrite')) {
                 return $output->writeln('<error>View already exists.</error>');
             } else {
                 $this->filesystem->delete($view);
             }
         }
         $this->filesystem->write($view, $content);
     }
     return $output->writeln('<info>View created successfully.</info>');
 }

 /**
  * Get a list linking an item name with the property it refers to and what kind of collection it is.
  * Ex: [
  *   "byItemName" => "user" => ["property" => "users", "behavior" => "list", "methods" => ["add", "remove"]],
  *   "byProperty" => "users" => ["itemName" => "user", "behavior" => "list", "methods" => ["add", "remove"]]
  * ]
  *
  * @param array  $properties The properties of the object to read.
  * @param \Doctrine\Common\Annotations\Reader $annotationReader The annotation reader to use.
  *
  * @return array The described list.
  */
 public static function getCollectionsItemNames($properties, $annotationReader)
 {
     $objectCollectionsItemNames = array("byProperty" => array(), "byItemName" => array());
     foreach ($properties as $propertyName => $property) {
         $annotation = null;
         $behavior = null;
         foreach (self::$collectionAnnotationClasses as $annotationBehavior => $annotationClass) {
             $annotation = $annotationReader->getPropertyAnnotation($property, $annotationClass);
             if ($annotation !== null) {
                 $behavior = $annotationBehavior;
                 break;
             }
         }
         if ($annotation !== null) {
             // get the item name, or deduce it (singularize the property name)
             $itemName = $annotation->getItemName();
             if ($itemName === null) {
                 $itemName = Inflector::singularize($propertyName);
             }
             $objectCollectionsItemNames["byItemName"][$itemName] = array("property" => $propertyName, "behavior" => $behavior, "methods" => $annotation->getMethods());
             $objectCollectionsItemNames["byProperty"][$propertyName] = array("itemName" => $itemName, "behavior" => $behavior, "methods" => $annotation->getMethods());
         }
     }
     return $objectCollectionsItemNames;
 }

 /**
  * @param string $id
  *
  * @return InstanceResource
  */
 public function get($id)
 {
     $instanceClassName = Inflector::singularize(static::class);
     $uri = sprintf('%s/%s', $this->uri, $id);
     /** @var InstanceResource $resource */
     $resource = new $instanceClassName($this->transport, $uri);
     return $resource;
 }

 /**
  * Singularifies a given value.
  *
  * @param string $value
  *
  * @return string
  */
 protected function singularize($value)
 {
     $singularified = Inflector::singularize($value);
     if (is_array($singularified)) {
         $singularified = end($singularified);
     }
     return $singularified;
 }

 /**
  * Parse a response body into a collection
  *
  * @param  string $data
  *
  * @return ResultCollection
  */
 public static function parseResultCollection($data)
 {
     $responseBody = json_decode($data, true);
     $rootKey = self::getRootKey($responseBody);
     $data = self::getResultForRootKey($responseBody, $rootKey);
     $className = Inflector::singularize(Inflector::classify($rootKey));
     $resultCollection = new ResultCollection();
     return $resultCollection->fromArrayWithObjects($data, $className);
 }

 /**
  * @param string $name
  *
  * @throws InvalidArgumentException
  *
  * @return ApiInterface
  */
 public function api($name)
 {
     $name = Inflector::singularize($name);
     $apis = ['author', 'billing', 'bundle', 'category', 'expertise', 'language', 'locale', 'project', 'template', 'user'];
     if (!in_array($name, $apis, true)) {
         throw new InvalidArgumentException(sprintf('Undefined api instance called: "%s"', $name));
     }
     $class = sprintf('Textmaster\\Api\\%s', ucfirst($name));
     return new $class($this);
 }

 public function __construct(FormatterManager $formatterManager, $dataProviderName, $dataSingularName = null, ProxySourceCollection $collection = null, FilterInterface $filter, MapInterface $map, ProxySourceItemFactoryInterface $factory = null)
 {
     $this->formatterManager = $formatterManager;
     $this->dataProviderName = $dataProviderName;
     $this->dataSingularName = $dataSingularName ?: Inflector::singularize($dataProviderName);
     $this->collection = $collection ?: new ProxySourceCollection();
     $this->filter = $filter ?: new NullFilter();
     $this->map = $map ?: new NullMap();
     $this->factory = $factory ?: new SimpleProxySourceItemFactory();
 }

 /**
  * @param TypeInterface $type
  */
 public function buildType(TypeInterface $type)
 {
     $base_manager_class_name = Inflector::classify($type->getName());
     $type_class_name = Inflector::classify(Inflector::singularize($type->getName()));
     $base_class_build_path = $this->getBuildPath() ? "{$this->getBuildPath()}/Manager/Base/{$base_manager_class_name}.php" : null;
     $result = [];
     $result[] = '<?php';
     $result[] = '';
     if ($this->getStructure()->getConfig('header_comment')) {
         $result = array_merge($result, explode("\n", $this->getStructure()->getConfig('header_comment')));
         $result[] = '';
     }
     if ($this->getStructure()->getNamespace()) {
         $base_class_namespace = $this->getStructure()->getNamespace() . '\\Manager\\Base';
         $type_class_name = '\\' . ltrim($this->getStructure()->getNamespace(), '\\') . '\\' . $type_class_name;
     } else {
         $base_class_namespace = 'Manager\\Base';
     }
     $result[] = 'namespace ' . $base_class_namespace . ';';
     $result[] = '';
     $result[] = '/**';
     $result[] = ' * @package ' . $base_class_namespace;
     $result[] = ' */';
     $interfaces = $traits = [];
     foreach ($type->getTraits() as $interface => $implementations) {
         if ($interface != '--just-paste-trait--') {
             $interfaces[] = '\\' . ltrim($interface, '\\');
         }
         if (count($implementations)) {
             foreach ($implementations as $implementation) {
                 $traits[] = '\\' . ltrim($implementation, '\\');
             }
         }
     }
     $result[] = 'abstract class ' . $base_manager_class_name . ' extends \\ActiveCollab\\DatabaseObject\\Entity\\Manager';
     $result[] = '{';
     $result[] = '    /**';
     $result[] = '     * Return type that this manager works with.';
     $result[] = '     *';
     $result[] = '     * @return string';
     $result[] = '     */';
     $result[] = '    public function getType()';
     $result[] = '    {';
     $result[] = '        return ' . var_export($type_class_name, true) . ';';
     $result[] = '    }';
     $result[] = '}';
     $result[] = '';
     $result = implode("\n", $result);
     if ($this->getBuildPath()) {
         file_put_contents($base_class_build_path, $result);
     } else {
         eval(ltrim($result, '<?php'));
     }
     $this->triggerEvent('on_class_built', [$base_manager_class_name, $base_class_build_path]);
 }

 /**
  * Singularize the $plural word if count == 1. If $singular is passed, it 
  * will be used instead of trying to use doctrine\inflector
  *
  * @param string  $plural   - chicken
  * @param int     $count      - e.g. 4
  * @param string  $singular     - (optional) chickens
  * @return string             
  */
 public static function singularize($plural, $count = 1, $singular = null)
 {
     $count = intval($count);
     if ($count != 1) {
         return $plural;
     }
     if (null == $singular) {
         $singular = \Doctrine\Common\Inflector\Inflector::singularize($plural);
     }
     return $singular;
 }