PHP FormInterface::isRoot方法代码示例

 public function buildView(FormView $view, FormInterface $form, array $options)
 {
     // Actual form root.
     if ($form->isRoot() && $view->parent === null) {
         if (!$options['jquery_validation']) {
             return;
         }
         $validation_groups = FormHelper::getValidationGroups($form);
         $contextBuilder = new FormRuleContextBuilder();
         $view->vars['rule_builder'] = $contextBuilder;
         $view->vars['rule_builder_children'] = array();
         if ($validation_groups === null) {
             $validation_groups = array(Constraint::DEFAULT_GROUP);
         }
     } else {
         $rootView = FormHelper::getViewRoot($view);
         if (!$this->hasRuleBuilderContext($rootView)) {
             return;
         }
         $contextBuilder = $this->getRuleBuilder($rootView);
         $validation_groups = FormHelper::getValidationGroups($form);
     }
     if ($validation_groups !== null) {
         $contextBuilder->addGroup($view, $validation_groups);
     }
 }

    public function validate(FormInterface $form)
    {
        if (!$form->isSynchronized()) {
            $form->addError(new FormError('The value is invalid'));
        }

        if (count($form->getExtraData()) > 0) {
            $form->addError(new FormError('This form should not contain extra fields'));
        }

        if ($form->isRoot() && isset($_SERVER['CONTENT_LENGTH'])) {
            $length = (int) $_SERVER['CONTENT_LENGTH'];
            $max = trim(ini_get('post_max_size'));

            switch (strtolower(substr($max, -1))) {
                // The 'G' modifier is available since PHP 5.1.0
                case 'g':
                    $max *= 1024;
                case 'm':
                    $max *= 1024;
                case 'k':
                    $max *= 1024;
            }

            if ($length > $max) {
                $form->addError(new FormError('The uploaded file was too large. Please try to upload a smaller file'));
            }
        }
    }

 /**
  * Validates the form and its domain object.
  *
  * @param FormInterface $form A FormInterface instance
  */
 public function validate(FormInterface $form)
 {
     if ($form->isRoot()) {
         $mapping = array();
         $forms = array();
         $this->buildFormPathMapping($form, $mapping);
         $this->buildDataPathMapping($form, $mapping);
         $this->buildNamePathMapping($form, $forms);
         $this->resolveMappingPlaceholders($mapping, $forms);
         // Validate the form in group "Default"
         // Validation of the data in the custom group is done by validateData(),
         // which is constrained by the Execute constraint
         if ($form->hasAttribute('validation_constraint')) {
             $violations = $this->validator->validateValue($form->getData(), $form->getAttribute('validation_constraint'), self::getFormValidationGroups($form));
         } else {
             $violations = $this->validator->validate($form);
         }
         if ($violations) {
             foreach ($violations as $violation) {
                 $propertyPath = $violation->getPropertyPath();
                 $template = $violation->getMessageTemplate();
                 $parameters = $violation->getMessageParameters();
                 $error = new FormError($template, $parameters);
                 foreach ($mapping as $mappedPath => $child) {
                     if (preg_match($mappedPath, $propertyPath)) {
                         $child->addError($error);
                         continue 2;
                     }
                 }
                 $form->addError($error);
             }
         }
     }
 }

 /**
  * Navigates to the Root form to define if cascading should be done.
  *
  * @param FormInterface $form
  * @return boolean
  */
 public function getRootFormCascadeOption(FormInterface $form)
 {
     if (!$form->isRoot()) {
         return $this->getRootFormCascadeOption($form->getParent());
     }
     return $form->getConfig()->getOption('cascade_filter', false);
 }

 public function interactWith(FormInterface $form, HelperSet $helperSet, InputInterface $input, OutputInterface $output)
 {
     if (!$form->isRoot()) {
         throw new CanNotInteractWithForm('This interactor only works with root forms');
     }
     if ($input->isInteractive()) {
         throw new CanNotInteractWithForm('This interactor only works with non-interactive input');
     }
     /*
      * We need to adjust the input values for repeated types by copying the provided value to both of the repeated
      * fields. We only loop through the top-level fields, since there are no command options for deeper lying fields
      * anyway.
      *
      * The fix was provided by @craigh
      *
      * P.S. If we need to add another fix like this, we should move this out to dedicated "input fixer" classes.
      */
     foreach ($form->all() as $child) {
         $config = $child->getConfig();
         $name = $child->getName();
         if ($config->getType()->getInnerType() instanceof RepeatedType && $input->hasOption($name)) {
             $input->setOption($name, [$config->getOption('first_name') => $input->getOption($name), $config->getOption('second_name') => $input->getOption($name)]);
         }
     }
     // use the original input as the submitted data
     return $input;
 }

 /**
  * {@inheritdoc}
  */
 public function finishView(FormView $view, FormInterface $form, array $options)
 {
     if ($form->isRoot()) {
         $view->vars['help'] = 'form.required_fields.help';
         $view->children['submit']->vars['label'] = 'form.submit.label';
         $view->children['submit']->vars['render_as_action'] = true;
     }
 }

 /**
  * @param FormInterface $form
  * @return array
  */
 protected function getFormErrorMessages(FormInterface $form)
 {
     $errors = [];
     foreach ($form->getErrors() as $error) {
         if ($form->isRoot()) {
             $errors[] = $this->toErrorArray($error);
         } else {
             $errors[] = $this->toErrorArray($error, $form);
         }
     }
     return $errors;
 }

 /**
  * Adds a CSRF field to the root form view.
  *
  * @param FormView      $view The form view
  * @param FormInterface $form The form
  */
 public function buildView(FormView $view, FormInterface $form)
 {
     if ($form->isRoot() && $form->hasChildren() && $form->hasAttribute('csrf_field_name')) {
         $name = $form->getAttribute('csrf_field_name');
         $csrfProvider = $form->getAttribute('csrf_provider');
         $intention = $form->getAttribute('csrf_intention');
         $factory = $form->getAttribute('csrf_factory');
         $data = $csrfProvider->generateCsrfToken($intention);
         $csrfForm = $factory->createNamed('hidden', $name, $data, array('property_path' => false));
         $view->addChild($csrfForm->createView($view));
     }
 }

 /**
  * {@inheritdoc}
  */
 public function buildView(FormView $view, FormInterface $form, array $options)
 {
     if (!$form->isRoot() && isset($options['rules'])) {
         $rules = $options['rules'];
         $innerType = $form->getConfig()->getType()->getInnerType();
         if (($innerType instanceof NumberType || $innerType instanceof IntegerType) && !in_array('numeric', $rules)) {
             $rules[] = 'numeric';
         }
         $ruleParser = new RulesParser($form, $view, $rules);
         $attr = $ruleParser->getAttributes();
         // Set form attributes based on rules
         $view->vars['required'] = in_array('required', $attr);
         $view->vars['attr'] += $attr;
     }
 }

 /**
  * Gets all the errors in the current $field and adds them to $_errors, to
  * get all errors in the form and its children recursively.
  * Also adds display name to error-message.
  *
  * @param  FormInterface $field Field to get Errors from
  */
 protected function _getErrors(FormInterface $field)
 {
     if ($field->getConfig()->getOption('label')) {
         $label = $this->_translator->trans($field->getConfig()->getOption('label'));
     } else {
         $label = ucfirst(trim(strtolower(preg_replace(array('/([A-Z])/', '/[_\\s]+/'), array('_$1', ' '), $field->getName()))));
     }
     $fieldErrors = array();
     foreach ($field->getErrors() as $error) {
         // don't show label if error is on the whole form
         $fieldErrors[] = $field->isRoot() ? $error->getMessage() : $label . ': ' . $error->getMessage();
     }
     $this->_errors[] = $fieldErrors;
     foreach ($field->all() as $child) {
         $this->_getErrors($child);
     }
 }

 protected function getErrorMessages(FormInterface $form)
 {
     $errors = array();
     foreach ($form->getErrors() as $key => $error) {
         if ($form->isRoot()) {
             $errors[] = '#: ' . $error->getMessage();
         } else {
             $errors[] = $error->getMessage() . '. ' . implode(', ', $error->getMessageParameters());
         }
     }
     foreach ($form->all() as $child) {
         if (!$child->isValid()) {
             $errorMessages = $this->getErrorMessages($child);
             if (is_array($errorMessages)) {
                 $errors = array_merge($errors, $errorMessages);
             } else {
                 $errors[] = $child->getName() . ': ' . $errorMessages;
             }
         }
     }
     return $errors;
 }

 /**
  * Returns whether the data of a form may be walked.
  *
  * @param  FormInterface $form The form to test.
  *
  * @return Boolean Whether the graph walker may walk the data.
  */
 private static function allowDataWalking(FormInterface $form)
 {
     $data = $form->getData();
     // Scalar values cannot have mapped constraints
     if (!is_object($data) && !is_array($data)) {
         return false;
     }
     // Root forms are always validated
     if ($form->isRoot()) {
         return true;
     }
     // Non-root forms are validated if validation cascading
     // is enabled in all ancestor forms
     while (null !== ($form = $form->getParent())) {
         if (!$form->getConfig()->getOption('cascade_validation')) {
             return false;
         }
     }
     return true;
 }

 private function requiresValidConstraint(FormInterface $form)
 {
     $formConfig = $form->getConfig();
     return !$form->isRoot() && $formConfig->getCompound() && $formConfig->getMapped() && $formConfig->getDataClass() !== null;
 }

 /**
  * Gets the form data to which a property path applies
  *
  * @param FormInterface $form
  * @return object|null
  */
 private function resolveDataSource(FormInterface $form)
 {
     if ($form->isRoot()) {
         // Nothing to do if root
         $dataForm = $form->getData();
     } else {
         $dataForm = $form;
         while ($dataForm->getConfig()->getDataClass() === null) {
             $dataForm = $form->getParent();
         }
     }
     $data = $dataForm->getData();
     return array($data, $data === null ? $dataForm->getConfig()->getDataClass() : get_class($data));
 }