PHP Inflector::singularize方法代码示例

 /**
  * @param \ReflectionClass $class
  * @param ResourceEntityInterface $entity
  * @param array $relationships
  * @return self
  */
 protected function setRelationships(\ReflectionClass $class, ResourceEntityInterface $entity, array $relationships)
 {
     foreach ($relationships as $relationship => $value) {
         $camelCased = Inflector::camelize($relationship);
         if (is_array($value)) {
             $getter = DefaultMutator::GET . $camelCased;
             $singular = Inflector::singularize($camelCased);
             $remover = DefaultMutator::REMOVE . $singular;
             $adder = DefaultMutator::ADD . $singular;
             // @todo Improve algorithm.
             foreach ($entity->{$getter}() as $item) {
                 $entity->{$remover}($item);
             }
             foreach ($value as $item) {
                 $entity->{$adder}($item);
             }
         } else {
             $method = DefaultMutator::SET . $camelCased;
             if ($class->hasMethod($method)) {
                 $entity->{$method}($value);
             }
         }
     }
     return $this;
 }

 /**
  * Serialize a collection.
  *
  * @param string $resourceKey
  * @param array  $data
  *
  * @return array
  */
 public function collection($resourceKey, array $data)
 {
     $dataResponse = [];
     $resourceKey = strtolower($resourceKey);
     $pluralize = Inflector::pluralize($resourceKey);
     $singularize = Inflector::singularize($resourceKey);
     if (!$this->scope->hasParent()) {
         $dataResponse[$pluralize] = [$singularize => $data];
     } else {
         $dataResponse = [$singularize => $data];
     }
     return $dataResponse;
 }

 /**
  * Searches for add and remove methods.
  */
 protected function findAdderAndRemover()
 {
     $reflClass = new \ReflectionClass($this->object);
     $propertyName = Inflector::classify(Inflector::singularize($this->propertyName));
     $addMethod = 'add' . $propertyName;
     $removeMethod = 'remove' . $propertyName;
     $addMethodFound = $this->isAccessible($reflClass, $addMethod, 1);
     $removeMethodFound = $this->isAccessible($reflClass, $removeMethod, 1);
     if ($addMethodFound && $removeMethodFound) {
         $this->addMethod = $addMethod;
         $this->removeMethod = $removeMethod;
     }
     if (!$addMethodFound || !$removeMethodFound) {
         throw new NoSuchPropertyException(sprintf('Not found a public methods "%s()" and/or "%s()" on class %s', $addMethod, $removeMethod, $reflClass->name));
     }
 }

 /**
  * Get relation query
  *
  * @return \Blast\Orm\Query
  */
 public function getQuery()
 {
     if (null !== $this->query) {
         return $this->query;
     }
     $provider = $this->createProvider($this->getEntity());
     $foreignProvider = $this->createProvider($this->getForeignEntity());
     $foreignKey = $this->getForeignKey();
     $junction = $this->getJunction();
     $junctionLocalKey = $this->getJunctionLocalKey();
     $junctionForeignKey = $this->getJunctionForeignKey();
     $data = $provider->extract();
     $localKey = $provider->getDefinition()->getPrimaryKeyName();
     //determine foreign key
     if ($foreignKey === null) {
         $foreignKey = $foreignProvider->getDefinition()->getPrimaryKeyName();
     }
     //determine through
     if (!is_string($junction) || $junction === null) {
         $junction = Inflector::singularize($provider->getDefinition()->getTableName()) . '_' . Inflector::singularize($foreignProvider->getDefinition()->getTableName());
     }
     //determine through local key
     if ($junctionLocalKey === null) {
         $junctionLocalKey = Inflector::singularize($provider->getDefinition()->getTableName()) . '_' . $localKey;
     }
     //determine through foreign key
     if ($junctionForeignKey === null) {
         $junctionForeignKey = Inflector::singularize($foreignProvider->getDefinition()->getTableName()) . '_' . $foreignKey;
     }
     $query = new Query($provider->getDefinition()->getMapper()->getConnection());
     //prepare query for foreign table
     $foreignQuery = $foreignProvider->getDefinition()->getMapper()->setConnection($this->getConnection())->select();
     //get relations by through db object
     if (isset($data[$localKey])) {
         $junctionProvider = is_string($junction) ? $this->createProvider($junction) : $junction;
         $junctionMapper = $junctionProvider->getDefinition()->getMapper();
         $junctionMapper->setConnection($this->getConnection());
         if (true) {
         }
         $results = $junctionMapper->select([$junctionForeignKey])->where($query->expr()->eq($junctionLocalKey, $data[$localKey]))->execute(HydratorInterface::HYDRATE_RAW);
         //set conditions on foreign query
         foreach ($results as $result) {
             $foreignQuery->where($query->expr()->eq($foreignKey, $result[$junctionForeignKey]));
         }
     }
     $this->query = $foreignQuery;
     return $this->query;
 }

 /**
  * @param ClassMetadataInfo $metadata
  * @param string            $type
  * @param string            $fieldName
  * @param string|null       $typeHint
  * @param string|null       $defaultValue
  *
  * @return string
  */
 protected function generateEntityStubMethod(ClassMetadataInfo $metadata, $type, $fieldName, $typeHint = null, $defaultValue = null)
 {
     $methodName = $type . Inflector::classify($fieldName);
     $variableName = Inflector::camelize($fieldName);
     if (in_array($type, array("add", "remove"))) {
         $methodName = Inflector::singularize($methodName);
         $variableName = Inflector::singularize($variableName);
     }
     if ($this->hasMethod($methodName, $metadata)) {
         return '';
     }
     $this->staticReflection[$metadata->name]['methods'][] = strtolower($methodName);
     $var = sprintf('%sMethodTemplate', $type);
     $template = static::${$var};
     $methodTypeHint = null;
     $types = Type::getTypesMap();
     $variableType = $typeHint ? $this->getType($typeHint) : null;
     if ($typeHint && !isset($types[$typeHint])) {
         $variableType = '\\' . ltrim($variableType, '\\');
         $methodTypeHint = '\\' . $typeHint . ' ';
     }
     $replacements = array('<description>' => ucfirst($type) . ' ' . $variableName, '<methodTypeHint>' => $methodTypeHint, '<variableType>' => $variableType, '<variableName>' => $variableName, '<methodName>' => $methodName, '<fieldName>' => $fieldName, '<variableDefault>' => $defaultValue !== null ? ' = ' . $defaultValue : '', '<entity>' => $this->getClassName($metadata));
     $method = str_replace(array_keys($replacements), array_values($replacements), $template);
     return $this->prefixCodeWithSpaces($method);
 }

 /**
  * @param \Doctrine\ORM\Mapping\ClassMetadata $meta
  * @param \Nette\ComponentModel\Component $component
  * @param mixed $entity
  * @return boolean
  */
 public function save(ClassMetadata $meta, Component $component, $entity)
 {
     if (!$component instanceof BaseControl) {
         return false;
     }
     $name = $component->getOption(self::FIELD_NAME, $component->getName());
     $value = $component->getValue();
     if ($this->accessor->isWritable($entity, $name) && !$meta->hasAssociation($name)) {
         try {
             $this->accessor->setValue($entity, $name, $value);
             return true;
         } catch (\Kdyby\Doctrine\MemberAccessException $e) {
         }
     }
     if (!$meta->hasAssociation($name)) {
         return false;
     }
     $value = $component->getValue();
     $entityClass = $this->relatedMetadata($entity, $name)->getName();
     $repository = $this->entityManager->getRepository($entityClass);
     if ($meta->isCollectionValuedAssociation($name)) {
         $property = \Doctrine\Common\Util\Inflector::singularize($name);
         foreach ($repository->findAll() as $associatedEntity) {
             if (in_array($associatedEntity->id, $value)) {
                 $hasMethod = 'has' . ucfirst($property);
                 if (!$entity->{$hasMethod}($associatedEntity)) {
                     $addMethod = 'add' . ucfirst($property);
                     $entity->{$addMethod}($associatedEntity);
                 }
             } else {
                 $removeMethod = 'remove' . ucfirst($property);
                 $entity->{$removeMethod}($associatedEntity);
             }
         }
     } elseif ($value === null || ($value = $repository->find($value))) {
         if ($this->accessor->isWritable($entity, $name)) {
             try {
                 $this->accessor->setValue($entity, $name, $value);
             } catch (\Kdyby\Doctrine\MemberAccessException $e) {
                 return false;
             }
         }
     }
     return true;
 }

 /**
  * {@inheritdoc}
  */
 protected function generateEntityStubMethod(ClassMetadataInfo $metadata, $type, $fieldName, $typeHint = null, $defaultValue = null)
 {
     $methodName = $type . Inflector::classify($fieldName);
     if (in_array($type, array("add", "remove"))) {
         $methodName = Inflector::singularize($methodName);
     }
     if ($this->hasMethod($methodName, $metadata)) {
         return '';
     }
     $this->staticReflection[$metadata->name]['methods'][] = $methodName;
     $var = sprintf('%sMethodTemplate', $type);
     $template = self::${$var};
     $methodTypeHint = null;
     $types = Type::getTypesMap();
     $variableType = $typeHint ? $this->getType($typeHint) . ' ' : null;
     if ($typeHint && !isset($types[$typeHint])) {
         $variableType = '\\' . ltrim($variableType, '\\');
         $methodTypeHint = '\\' . $typeHint . ' ';
     } elseif ($variableType[0] == '\\') {
         $variableType = '\\' . ltrim($variableType, '\\');
         $methodTypeHint = '\\' . ltrim($variableType, '\\');
     }
     switch (trim($variableType)) {
         case 'bool':
         case 'boolean':
             $variableCast = '(bool) ';
             break;
         case 'int':
         case 'integer':
             $variableCast = '(int) ';
             break;
         case 'float':
         case 'double':
             $variableCast = '(float) ';
             break;
         case 'string':
             $variableCast = '(string) ';
             break;
         default:
             $variableCast = '';
     }
     $variableName = Inflector::camelize($fieldName);
     if ($metadata->hasField($fieldName) && $metadata->isNullable($fieldName)) {
         $nullable = true;
     } else {
         $nullable = false;
     }
     if ($nullable && $variableCast) {
         $variableCast = sprintf('$%s === null ? null : %s', $variableName, $variableCast);
     }
     $replacements = array('<description>' => ucfirst($type) . ' ' . $fieldName, '<methodTypeHint>' => $methodTypeHint, '<variableType>' => $variableType, '<variableCast>' => $variableCast, '<variableName>' => $variableName, '<methodName>' => $methodName, '<fieldName>' => $fieldName, '<variableDefault>' => $defaultValue !== null ? ' = ' . $defaultValue : ($nullable ? ' = null' : ''), '<entity>' => $this->getClassName($metadata));
     $method = str_replace(array_keys($replacements), array_values($replacements), $template);
     return $this->prefixCodeWithSpaces($method);
 }