/**
  * Guess the nullable rule.
  *
  * @param FormBuilder $builder
  */
 public function guess(FormBuilder $builder)
 {
     $fields = $builder->getFields();
     foreach ($fields as &$field) {
         // Skip if nullable
         if (isset($field['rules']) && in_array('nullable', $field['rules'])) {
             continue;
         }
         /**
          * If the field depends on other fields we
          * won't add nullable here because validation
          * will not be performed on this field.
          */
         if (!empty($field['rules'])) {
             if (preg_grep("/required_.*/", $field['rules'])) {
                 continue;
             }
         }
         // If not required then nullable.
         if (isset($field['required']) && $field['required'] == false) {
             $field['rules'][] = 'nullable';
         }
         // If not specified then it's nullable
         if (!isset($field['required'])) {
             $field['rules'][] = 'nullable';
         }
     }
     $builder->setFields($fields);
 }

 /**
  * Guess the HREF for a button.
  *
  * @param FormBuilder $builder
  */
 public function guess(FormBuilder $builder)
 {
     $buttons = $builder->getButtons();
     $entry = $builder->getFormEntry();
     // Nothing to do if empty.
     if (!($section = $this->sections->active())) {
         return;
     }
     foreach ($buttons as &$button) {
         if (isset($button['attributes']['href'])) {
             continue;
         }
         switch (array_get($button, 'button')) {
             case 'cancel':
                 $button['attributes']['href'] = $section->getHref();
                 break;
             case 'delete':
                 $button['attributes']['href'] = $section->getHref('delete/' . $entry->getId());
                 break;
             default:
                 // Determine the HREF based on the button type.
                 $type = array_get($button, 'button');
                 if ($type && !str_contains($type, '\\') && !class_exists($type)) {
                     $button['attributes']['href'] = $section->getHref($type . '/{entry.id}');
                 }
                 break;
         }
     }
     $builder->setButtons($buttons);
 }

 /**
  * Handle the form.
  *
  * @param FormBuilder $builder
  */
 public function handle(FormBuilder $builder)
 {
     if (!$builder->canSave()) {
         return;
     }
     $builder->saveForm();
 }

 /**
  * Translate form fields.
  *
  * @param FormBuilder $builder
  */
 public function translate(FormBuilder $builder)
 {
     $translations = [];
     $defaultLocale = config('streams::locales.default');
     $enabledLocales = config('streams::locales.enabled');
     /*
      * For each field if the assignment is translatable
      * then duplicate it and set a couple simple
      * parameters to assist in rendering.
      */
     foreach ($builder->getFields() as $field) {
         if (!array_get($field, 'translatable', false)) {
             $translations[] = $field;
             continue;
         }
         foreach ($enabledLocales as $locale) {
             $translation = $field;
             array_set($translation, 'locale', $locale);
             array_set($translation, 'hidden', $locale !== $locale);
             if ($value = array_get($field, 'values.' . $locale)) {
                 array_set($translation, 'value', $value);
             }
             if ($defaultLocale !== $locale) {
                 array_set($translation, 'hidden', true);
                 array_set($translation, 'required', false);
                 array_set($translation, 'rules', array_diff(array_get($translation, 'rules', []), ['required']));
             }
             $translations[] = $translation;
         }
     }
     $builder->setFields($translations);
 }

 /**
  * Guess the button from the hint.
  *
  * @param FormBuilder $builder
  */
 public function guess(FormBuilder $builder)
 {
     $buttons = $builder->getButtons();
     $module = $this->modules->active();
     /*
      * This will break if we can't figure
      * out what the active module is.
      */
     if (!$module instanceof Module) {
         return;
     }
     foreach ($buttons as &$button) {
         if (isset($button['text'])) {
             continue;
         }
         if (!isset($button['button'])) {
             continue;
         }
         $text = $module->getNamespace('button.' . $button['button']);
         if (!isset($button['text']) && $this->translator->has($text)) {
             $button['text'] = $text;
         }
         if ((!isset($button['text']) || !$this->translator->has($button['text'])) && $this->config->get('streams::system.lazy_translations')) {
             $button['text'] = ucwords($this->string->humanize($button['button']));
         }
         if (!isset($button['text'])) {
             $button['text'] = $text;
         }
     }
     $builder->setButtons($buttons);
 }

 /**
  * Handle the form.
  */
 public function handle()
 {
     $form = $this->builder->getForm();
     $model = $this->builder->getModel();
     /**
      * If the model is already instantiated
      * then use it as is.
      */
     if (is_object($model)) {
         $form->setModel($model);
         return;
     }
     /**
      * If no model is set, try guessing the
      * model based on best practices.
      */
     if ($model === null) {
         $parts = explode('\\', str_replace('FormBuilder', 'Model', get_class($this->builder)));
         unset($parts[count($parts) - 2]);
         $model = implode('\\', $parts);
         $this->builder->setModel($model);
     }
     /**
      * If the model does not exist or
      * is disabled then skip it.
      */
     if (!$model || !class_exists($model)) {
         $this->builder->setModel(null);
         return;
     }
     /**
      * Set the model on the form!
      */
     $form->setModel(app($model));
 }

 /**
  * Save the form.
  *
  * @param FormBuilder|ConfigurationFormBuilder $builder
  * @return bool|mixed
  */
 public function save(FormBuilder $builder)
 {
     $namespace = $builder->getFormEntry() . '::';
     /* @var FieldType $field */
     foreach ($builder->getFormFields() as $field) {
         $this->configurations->set($namespace . $field->getField(), $builder->getScope(), $builder->getFormValue($field->getInputName()));
     }
 }

 /**
  * Normalize button input.
  *
  * @param FormBuilder $builder
  */
 public function normalize(FormBuilder $builder)
 {
     $buttons = $builder->getButtons();
     foreach ($buttons as $key => &$button) {
         $button = $this->process($key, $button);
     }
     $builder->setButtons($buttons);
 }

 /**
  * Guess the field placeholders.
  *
  * @param FormBuilder $builder
  */
 public function guess(FormBuilder $builder)
 {
     $fields = $builder->getFields();
     $prefix = $builder->getFormOption('prefix');
     foreach ($fields as &$field) {
         array_set($field, 'prefix', array_get($field, 'prefix', $prefix));
     }
     $builder->setFields($fields);
 }

 /**
  * Save the form.
  *
  * @param FormBuilder $builder
  * @return bool|mixed
  */
 public function save(FormBuilder $builder)
 {
     $form = $builder->getForm();
     $namespace = $form->getEntry() . '::';
     /* @var FieldType $field */
     foreach ($form->getFields() as $field) {
         $this->preferences->set($namespace . $field->getField(), $form->getValue($field->getInputName()));
     }
 }

 /**
  * Return all the input from the form.
  *
  * @param  FormBuilder $builder
  * @return array
  */
 public function all(FormBuilder $builder)
 {
     $input = [];
     /* @var FieldType $field */
     foreach ($builder->getEnabledFormFields() as $field) {
         $input[$field->getInputName()] = $field->getValidationValue();
     }
     return $input;
 }

 /**
  * Set the form model object from the builder's model.
  *
  * @param SetDefaultParameters $command
  */
 public function handle()
 {
     /*
      * Set the form mode according
      * to the builder's entry.
      */
     if (!$this->builder->getFormMode()) {
         $this->builder->setFormMode($this->builder->getFormEntryId() || $this->builder->getEntry() ? 'edit' : 'create');
     }
     /*
      * Next we'll loop each property and look for a handler.
      */
     $reflection = new \ReflectionClass($this->builder);
     /* @var \ReflectionProperty $property */
     foreach ($reflection->getProperties(\ReflectionProperty::IS_PROTECTED) as $property) {
         if (in_array($property->getName(), $this->skips)) {
             continue;
         }
         /*
          * If there is no getter then skip it.
          */
         if (!method_exists($this->builder, $method = 'get' . ucfirst($property->getName()))) {
             continue;
         }
         /*
          * If the parameter already
          * has a value then skip it.
          */
         if ($this->builder->{$method}()) {
             continue;
         }
         /*
          * Check if we can transform the
          * builder property into a handler.
          * If it exists, then go ahead and use it.
          */
         $handler = str_replace('FormBuilder', 'Form' . ucfirst($property->getName()), get_class($this->builder));
         if (class_exists($handler)) {
             /*
              * Make sure the handler is
              * formatted properly.
              */
             if (!str_contains($handler, '@')) {
                 $handler .= '@handle';
             }
             $this->builder->{'set' . ucfirst($property->getName())}($handler);
             continue;
         }
         /*
          * If the handler does not exist and
          * we have a default handler, use it.
          */
         if ($default = array_get($this->defaults, $property->getName())) {
             $this->builder->{'set' . ucfirst($property->getName())}($default);
         }
     }
 }

 /**
  * Default the form actions when none are defined.
  *
  * @param FormBuilder $builder
  */
 public function defaults(FormBuilder $builder)
 {
     if ($builder->getActions() === []) {
         if ($builder->getFormMode() == 'create') {
             $builder->setActions(['save', 'save_create']);
         } else {
             $builder->setActions(['update', 'save_exit']);
         }
     }
 }

 /**
  * Normalize action input.
  *
  * @param FormBuilder $builder
  */
 public function normalize(FormBuilder $builder)
 {
     $form = $builder->getForm();
     $actions = $builder->getActions();
     $prefix = $form->getOption('prefix');
     foreach ($actions as $slug => &$action) {
         $action = $this->process($prefix, $slug, $action);
     }
     $builder->setActions($actions);
 }

 /**
  * Merge in registered properties.
  *
  * @param FormBuilder $builder
  */
 public function merge(FormBuilder $builder)
 {
     $buttons = $builder->getButtons();
     foreach ($buttons as &$parameters) {
         if ($button = $this->buttons->get(array_get($parameters, 'button'))) {
             $parameters = array_replace_recursive($button, $parameters);
         }
     }
     $builder->setButtons($buttons);
 }

 /**
  * Normalize the sections.
  *
  * @param FormBuilder $builder
  */
 public function normalize(FormBuilder $builder)
 {
     $sections = $builder->getSections();
     foreach ($sections as $slug => &$section) {
         if (is_string($section)) {
             $section = ['view' => $section];
         }
     }
     $builder->setSections($sections);
 }

 /**
  * Build the actions.
  *
  * @param FormBuilder $builder
  */
 public function build(FormBuilder $builder)
 {
     $form = $builder->getForm();
     $this->input->read($builder);
     foreach ($builder->getActions() as $action) {
         if (array_get($action, 'enabled', true)) {
             $form->addAction($this->factory->make($action));
         }
     }
 }

 /**
  * Save the form.
  *
  * @param FormBuilder $builder
  * @return bool|mixed
  */
 public function save(FormBuilder $builder)
 {
     $form = $builder->getForm();
     $namespace = $form->getEntry() . '::';
     /* @var FieldType $field */
     foreach ($form->getFields() as $field) {
         $key = $namespace . $field->getField();
         $value = $form->getValue($field->getInputName());
         $this->settings->set($key, $value);
     }
 }

 /**
  * Handle the command.
  *
  * @param Resolver  $resolver
  * @param Evaluator $evaluator
  */
 public function handle(Resolver $resolver, Evaluator $evaluator)
 {
     $evaluator->evaluate($resolver->resolve($this->builder->getOptions(), ['builder' => $this->builder]), ['builder' => $this->builder]);
     foreach ($this->builder->getOptions() as $key => $value) {
         $this->builder->setFormOption($key, $value);
     }
 }

 /**
  * Handle the event.
  */
 public function handle(Store $session)
 {
     /* @var MessageBag $errors */
     if ($errors = $session->get($this->builder->getOption('prefix') . 'errors')) {
         $this->builder->setFormErrors($errors);
     }
 }