From 64bc402d356a8c0194138fec3fa8fc69d9957ea7 Mon Sep 17 00:00:00 2001
From: Christian Leucht <c.leucht@inpsyde.com>
Date: Tue, 27 Jun 2023 14:55:27 +0200
Subject: [PATCH] ChoiceList // refactor internal structure to support
 "disabled"-attribute for checkbox, radio and options and allow in future to
 add more settings like "help"-text. View // complete refactor of markup to
 move away from <table> and be more flexible with styling elements. All
 elements on output will now have the "type" as modifier on the wrapper.
 Additionally the <label> and element itself will now also have a CSS class
 including the type. View/Button // introduce new "reset"- and "button"-types
 which will render a <button>

---
 docs/03 - create choices.md                   | 50 +++++++++++++++-
 src/AbstractFactory.php                       |  5 ++
 src/ChoiceList/ArrayChoiceList.php            | 53 +++++++++++++----
 src/ChoiceList/CallbackChoiceList.php         |  5 +-
 src/ChoiceList/ChoiceListInterface.php        |  2 +-
 src/Element/CollectionElement.php             | 15 ++---
 src/View/AttributeFormatterTrait.php          | 26 +++++++-
 src/View/Button.php                           | 37 ++++++++++++
 src/View/Checkbox.php                         |  6 +-
 src/View/Collection.php                       | 29 +++++----
 src/View/Form.php                             | 24 ++++----
 src/View/FormRow.php                          | 21 +++----
 src/View/Input.php                            |  3 +-
 src/View/Label.php                            |  6 +-
 src/View/Progress.php                         |  2 +
 src/View/Radio.php                            |  6 +-
 src/View/Select.php                           | 11 ++--
 src/View/Textarea.php                         |  1 +
 .../Unit/ChoiceList/ArrayChoiceListTest.php   | 48 +++++++++++----
 .../ChoiceList/CallbackChoiceListTest.php     |  8 ++-
 .../Unit/Element/CollectionElementTest.php    |  3 +-
 tests/phpunit/Unit/ElementFactoryTest.php     | 24 +++++---
 tests/phpunit/Unit/View/ButtonTest.php        | 59 +++++++++++++++++++
 tests/phpunit/Unit/View/FormRowTest.php       | 13 ++--
 24 files changed, 360 insertions(+), 97 deletions(-)
 create mode 100644 src/View/Button.php
 create mode 100644 tests/phpunit/Unit/View/ButtonTest.php

diff --git a/docs/03 - create choices.md b/docs/03 - create choices.md
index a591564..58580a8 100644
--- a/docs/03 - create choices.md	
+++ b/docs/03 - create choices.md	
@@ -6,7 +6,7 @@ The `ChoiceElement` allows us to add different choices. This package ships 2 imp
 
 To show the differences for both, here's a short example for a `<select>` which shows posts:
 
-**1. ArrayChoiceList**
+## `ArrayChoiceList`
 ```php
 <?php
 use ChriCo\Fields\Element\ChoiceElement;
@@ -41,7 +41,7 @@ $select = createElement(
 );
 ```
 
-**2. CallbackChoiceList**
+## `CallbackChoiceList`
 ```php
 <?php
 use ChriCo\Fields\Element\ChoiceElement;
@@ -84,3 +84,49 @@ $select = createElement(
 ```
 
 The main difference is: The `CallbackChoiceList` only loads the choices, when they are first time accessed in view. The `ArrayChoiceList` has already assigned the complete choice-values in it's constructor.
+
+## Structure of choices
+
+The choices have a new structure since version 2.1 which will be used internally and allows more flexibility.
+
+**Old structure** (still works)
+
+```php
+use ChriCo\Fields\Element\ChoiceElement;
+use ChriCo\Fields\ChoiceList\ArrayChoiceList;
+$data = [
+    'M' => 'Male',
+    'F' => 'Female',
+    'D' => 'Diverse'
+];
+
+// normal ArrayChoiceList
+$select = (new ChoiceElement('select'))
+	->withAttributes([ 'type' => 'select' ])
+	->withChoices(new ArrayChoiceList($data));
+```
+
+**New structure**
+```php
+use ChriCo\Fields\Element\ChoiceElement;
+use ChriCo\Fields\ChoiceList\ArrayChoiceList;
+$data = [
+    'M' => [
+        'label' => 'Male',
+        'disabled' => true,
+    ],
+    'F' => [
+        'label' => 'Female',
+    ]
+    'D' => [
+        'label' => 'Diverse'
+    ]
+];
+
+// normal ArrayChoiceList
+$select = (new ChoiceElement('select'))
+	->withAttributes([ 'type' => 'select' ])
+	->withChoices(new ArrayChoiceList($data));
+```
+
+As you can see we now have instead of `array<string|int, string>` mapping a more complex structure `array<string|int, array<{ label: string, disabled?:boolean }>`, which will allow us to additionally set `disabled`. The result is the same, but the "old structure" will be internally converted to "new structure".
\ No newline at end of file
diff --git a/src/AbstractFactory.php b/src/AbstractFactory.php
index 45f9624..0bfe273 100644
--- a/src/AbstractFactory.php
+++ b/src/AbstractFactory.php
@@ -57,6 +57,9 @@ abstract class AbstractFactory
 
         'textarea' => View\Textarea::class,
         'progress' => View\Progress::class,
+
+        'button' => View\Button::class,
+        'reset' => View\Button::class,
     ];
 
     /**
@@ -71,6 +74,7 @@ abstract class AbstractFactory
 
         'collection' => CollectionElement::class,
 
+        'button' => Element::class,
         'col' => Element::class,
         'color' => Element::class,
         'date' => Element::class,
@@ -87,6 +91,7 @@ abstract class AbstractFactory
         'range' => Element::class,
         'search' => Element::class,
         'submit' => Element::class,
+        'reset' => Element::class,
         'tel' => Element::class,
         'text' => Element::class,
         'textarea' => Element::class,
diff --git a/src/ChoiceList/ArrayChoiceList.php b/src/ChoiceList/ArrayChoiceList.php
index 43ccd20..4dec963 100644
--- a/src/ChoiceList/ArrayChoiceList.php
+++ b/src/ChoiceList/ArrayChoiceList.php
@@ -6,41 +6,72 @@
  * Class ArrayChoiceList
  *
  * @package ChriCo\Fields\ChoiceList
+ *
+ * @psalm-type SelectOption = array{
+ *     label: string,
+ *     value: string|int,
+ *     disabled: boolean,
+ * }
  */
 class ArrayChoiceList implements ChoiceListInterface
 {
-
     /**
-     * @var array
+     * @var array<string|int, SelectOption>
      */
     protected array $choices;
 
     /**
-     * ArrayChoiceList constructor.
-     *
      * @param array $choices
      */
     public function __construct(array $choices = [])
     {
-        $this->choices = $choices;
+        $this->choices = $this->prepareChoices($choices);
     }
 
-    /**
-     * {@inheritdoc}
-     */
     public function values(): array
     {
         return array_map('strval', array_keys($this->choices()));
     }
 
-    /**
-     * {@inheritdoc}
-     */
     public function choices(): array
     {
         return $this->choices;
     }
 
+    /**
+     * Internal function which migrates choices from [ $value => $name ]
+     * into the new [ $value => 'value' => $value, 'label' => $name, 'disabled' => false ]
+     * structure to allow more configuration and flexibility in future.
+     *
+     * @param array $choices
+     *
+     * @return array
+     */
+    protected function prepareChoices(array $choices): array
+    {
+        $prepared = [];
+        foreach ($choices as $value => $nameOrChoice) {
+            if (is_string($nameOrChoice)) {
+                $prepared[$value] = [
+                    'value' => $value,
+                    'label' => trim($nameOrChoice),
+                    'disabled' => false,
+                ];
+            } elseif (is_array($nameOrChoice)) {
+                $prepared[$value] = [
+                    'value' => $value,
+                    'label' => trim($nameOrChoice['label'] ?? ''),
+                    'disabled' => (bool) ($nameOrChoice['disabled'] ?? false),
+                ];
+            }
+        }
+
+        return array_filter(
+            $prepared,
+            static fn(array $choice) => $choice['label'] !== ''
+        );
+    }
+
     /**
      * @param array $values
      *
diff --git a/src/ChoiceList/CallbackChoiceList.php b/src/ChoiceList/CallbackChoiceList.php
index 21ce9ba..fb39824 100644
--- a/src/ChoiceList/CallbackChoiceList.php
+++ b/src/ChoiceList/CallbackChoiceList.php
@@ -9,7 +9,6 @@
  */
 class CallbackChoiceList extends ArrayChoiceList
 {
-
     /**
      * @var bool
      */
@@ -49,9 +48,9 @@ public function choices(): array
      */
     private function maybeLoadChoices(): bool
     {
-        if (! $this->isLoaded()) {
+        if (!$this->isLoaded()) {
             $callback = $this->callback;
-            $this->choices = $callback();
+            $this->choices = $this->prepareChoices($callback());
             $this->isLoaded = true;
 
             return true;
diff --git a/src/ChoiceList/ChoiceListInterface.php b/src/ChoiceList/ChoiceListInterface.php
index 9bf7e91..aa74daf 100644
--- a/src/ChoiceList/ChoiceListInterface.php
+++ b/src/ChoiceList/ChoiceListInterface.php
@@ -20,7 +20,7 @@ public function choices(): array;
     /**
      * Returns a unique list of all values for the choices.
      *
-     * @return string[]
+     * @return string[]|int[]
      */
     public function values(): array;
 
diff --git a/src/Element/CollectionElement.php b/src/Element/CollectionElement.php
index 3a69168..d9ec93e 100644
--- a/src/Element/CollectionElement.php
+++ b/src/Element/CollectionElement.php
@@ -136,16 +136,13 @@ public function withErrors(array $errors = []): CollectionElement
     {
         $this->allErrors = $errors;
 
-        array_walk(
-            $this->elements,
-            static function (ElementInterface $element) use ($errors): void {
-                $name = $element->name();
-                if (isset($errors[$name]) && $element instanceof ErrorAwareInterface) {
-                    $element->withErrors($errors);
-                    unset($errors[$name]);
-                }
+        foreach ($this->elements as $element) {
+            $name = $element->name();
+            if (isset($errors[$name]) && $element instanceof ErrorAwareInterface) {
+                $element->withErrors((array) $errors[$name]);
+                unset($errors[$name]);
             }
-        );
+        }
 
         // assign errors without matches to the collection itself.
         $this->errors = $errors;
diff --git a/src/View/AttributeFormatterTrait.php b/src/View/AttributeFormatterTrait.php
index 2da45e8..891dff0 100644
--- a/src/View/AttributeFormatterTrait.php
+++ b/src/View/AttributeFormatterTrait.php
@@ -2,6 +2,8 @@
 
 namespace ChriCo\Fields\View;
 
+use ChriCo\Fields\Element\ElementInterface;
+
 /**
  * Trait AttributeFormatterTrait
  *
@@ -9,7 +11,6 @@
  */
 trait AttributeFormatterTrait
 {
-
     /**
      * @var array
      */
@@ -94,4 +95,27 @@ public function escapeHtml($value): string
     {
         return esc_html((string) $value);
     }
+
+    /**
+     * Internal function to add additional selectors for type, type+elementName, type+elementType.
+     *
+     * @param array $attributes
+     * @param string $type
+     * @param ElementInterface $element
+     *
+     * @return array $attributes
+     */
+    public function buildCssClasses(array $attributes, string $type, ElementInterface $element): array
+    {
+        $classes = (array) ($attributes['class'] ?? []);
+
+        $classes[] = "form-{$type}";
+        if ($element->type() !== $type) {
+            $classes[] = "form-{$type}--{$element->type()}";
+        }
+
+        $attributes['class'] = implode(' ', $classes);
+
+        return $attributes;
+    }
 }
diff --git a/src/View/Button.php b/src/View/Button.php
new file mode 100644
index 0000000..bc682ef
--- /dev/null
+++ b/src/View/Button.php
@@ -0,0 +1,37 @@
+<?php declare(strict_types=1); # -*- coding: utf-8 -*-
+
+namespace ChriCo\Fields\View;
+
+use ChriCo\Fields\Element\ElementInterface;
+use ChriCo\Fields\Element\LabelAwareInterface;
+
+/**
+ * Class Input
+ *
+ * @package ChriCo\Fields\View
+ */
+class Button implements RenderableElementInterface
+{
+    use AttributeFormatterTrait;
+    use AssertElementInstanceOfTrait;
+
+    /**
+     * @param ElementInterface|LabelAwareInterface $element
+     *
+     * @return string
+     */
+    public function render(ElementInterface $element): string
+    {
+        // Every button should have a label (text).
+        $this->assertElementIsInstanceOf($element, LabelAwareInterface::class);
+
+        $attributes = $element->attributes();
+        $attributes = $this->buildCssClasses($attributes, 'element', $element);
+
+        return sprintf(
+            '<button %1$s>%2$s</button>',
+            $this->attributesToString($attributes),
+            $element->label(),
+        );
+    }
+}
diff --git a/src/View/Checkbox.php b/src/View/Checkbox.php
index a861d2a..b153825 100644
--- a/src/View/Checkbox.php
+++ b/src/View/Checkbox.php
@@ -44,18 +44,20 @@ public function render(ElementInterface $element): string
             $isMultiChoice = true;
         }
 
-        foreach ($choices as $key => $name) {
+        foreach ($choices as $key => $choice) {
             $elementAttr = $attributes;
             $elementAttr['value'] = $key;
             $elementAttr['checked'] = isset($selected[$key]);
+            $elementAttr['disabled'] = $choice['disabled'];
             $elementAttr['id'] = $isMultiChoice
                 ? $element->id() . '_' . $key
                 : $element->id();
+            $elementAttr = $this->buildCssClasses($elementAttr, 'element', $element);
 
             $label = sprintf(
                 '<label for="%s">%s</label>',
                 $this->escapeAttribute($elementAttr['id']),
-                $this->escapeHtml($name)
+                $this->escapeHtml($choice['label'])
             );
 
             $html[] = sprintf(
diff --git a/src/View/Collection.php b/src/View/Collection.php
index 9b27e15..8524506 100644
--- a/src/View/Collection.php
+++ b/src/View/Collection.php
@@ -15,7 +15,6 @@
  */
 class Collection implements RenderableElementInterface
 {
-
     use AttributeFormatterTrait;
     use AssertElementInstanceOfTrait;
 
@@ -36,9 +35,9 @@ public function __construct(ViewFactory $factory = null)
     /**
      * @param ElementInterface|Element\CollectionElement $element
      *
+     * @return string
      * @throws InvalidClassException
      *
-     * @return string
      */
     public function render(ElementInterface $element): string
     {
@@ -50,13 +49,13 @@ public function render(ElementInterface $element): string
             $element->elements(),
             function ($html, ElementInterface $next) use ($element, $row): string {
                 // Adding the CollectionElement name to the Element name and ID as prefix.
-                $next->withAttribute('id', $element->id().'_'.$next->id());
-                $next->withAttribute('name', $element->name().'['.$next->name().']');
+                $next->withAttribute('id', $element->id() . '_' . $next->id());
+                $next->withAttribute('name', $element->name() . '[' . $next->name() . ']');
 
                 // In case we have nested CollectionElement, then
-                // we don't want to nest "<table><tr>"-wrapper.
+                // we don't want to nest those when rendering.
                 if ($next instanceof Element\CollectionElement) {
-                   $html .= $this->render($next);
+                    $html .= $this->render($next);
                 } else {
                     $html .= $row->render($next);
                 }
@@ -66,12 +65,22 @@ function ($html, ElementInterface $next) use ($element, $row): string {
             ''
         );
 
+        $attributes = $element->attributes();
+        $attributes = $this->buildCssClasses($attributes, 'collection', $element);
+        // we do not want to get the "name" and "type" rendered as attribute on wrapper.
+        unset($attributes['name'], $attributes['type']);
+
         $errors = $this->factory->create(Errors::class)
             ->render($element);
-        $class = $errors !== ''
-            ? 'form-table--has-errors'
-            : '';
+        if ($errors !== '') {
+            $attributes['class'] .= ' form-collection--has-errors';
+        }
 
-        return sprintf('%1$s<table class="form-table %2$s">%3$s</table>', $errors, $class, $html);
+        return sprintf(
+            '%1$s<div %2$s>%3$s</div>',
+            $errors,
+            $this->attributesToString($attributes),
+            $html
+        );
     }
 }
diff --git a/src/View/Form.php b/src/View/Form.php
index b9ca45d..ca4755f 100644
--- a/src/View/Form.php
+++ b/src/View/Form.php
@@ -16,7 +16,6 @@
  */
 class Form implements RenderableElementInterface
 {
-
     use AttributeFormatterTrait;
     use AssertElementInstanceOfTrait;
 
@@ -37,9 +36,9 @@ public function __construct(ViewFactory $factory = null)
     /**
      * @param ElementInterface|FormInterface $element
      *
+     * @return string
      * @throws InvalidClassException|UnknownTypeException
      *
-     * @return string
      */
     public function render(ElementInterface $element): string
     {
@@ -57,20 +56,25 @@ static function ($html, ElementInterface $next) use ($element, $row): string {
             ''
         );
 
+        $attributes = $element->attributes();
+        // Don't re-use the "type" as attribute on <form>-tag.
+        unset($attributes['type']);
+        $classes = (string) ($attributes['class'] ?? '');
+        $classes .= 'form';
+        $attributes['class'] = $classes;
+
         $errors = $element instanceof ErrorAwareInterface
             ? $this->factory->create(Errors::class)
                 ->render($element)
             : '';
-
-        $class = $errors !== ''
-            ? 'form-table--has-errors'
-            : '';
-
-        $html = sprintf('%1$s <table class="form-table %2$s">%3$s</table>', $errors, $class, $html);
+        if ($errors !== '') {
+            $attributes['class'] .= ' form--has-errors';
+        }
 
         return sprintf(
-            '<form %s>%s</form>',
-            $this->attributesToString($element->attributes()),
+            '<form %1$s>%2$s %3$s</form>',
+            $this->attributesToString($attributes),
+            $errors,
             $html
         );
     }
diff --git a/src/View/FormRow.php b/src/View/FormRow.php
index d48bc49..5c4df21 100644
--- a/src/View/FormRow.php
+++ b/src/View/FormRow.php
@@ -55,39 +55,40 @@ public function render(ElementInterface $element): string
             : '';
 
         $label = $element instanceof LabelAwareInterface
+        && !in_array(
+            $element->type(),
+            ['submit', 'button', 'reset'],
+            true
+        )
             ? $this->factory->create(Label::class)
                 ->render($element)
             : '';
 
         $html = ($label !== '')
             ? sprintf(
-                '<th>%1$s</th><td>%2$s %3$s %4$s</td>',
+                '%1$s %2$s %3$s %4$s',
                 $label,
                 $field,
                 $description,
                 $errors
             )
             : sprintf(
-                '<td colspan="2">%1$s %2$s %3$s</td>',
+                '%1$s %2$s %3$s',
                 $field,
                 $description,
                 $errors
             );
 
-        $classes = ['form-row', 'form-row__' . $element->name(), 'form-row--' . $element->type()];
+        $rowAttributes = $this->buildCssClasses([], 'row', $element);;
         if ($errors !== '') {
-            $classes[] = 'form-row--has-errors';
+            $rowAttributes['class'] .= ' form-row--has-errors';
         }
         if ($element->type() === 'hidden') {
-            $classes[] = 'hidden';
+            $rowAttributes['class'] .= ' hidden';
         }
 
-        $rowAttributes = [
-            'class' => implode(' ', $classes),
-        ];
-
         return sprintf(
-            '<tr %s>%s</tr>',
+            '<div %s>%s</div>',
             $this->attributesToString($rowAttributes),
             $html
         );
diff --git a/src/View/Input.php b/src/View/Input.php
index 4e820fd..5c3b7fd 100644
--- a/src/View/Input.php
+++ b/src/View/Input.php
@@ -3,6 +3,7 @@
 namespace ChriCo\Fields\View;
 
 use ChriCo\Fields\Element\ElementInterface;
+use ChriCo\Fields\Element\LabelAwareInterface;
 
 /**
  * Class Input
@@ -11,7 +12,6 @@
  */
 class Input implements RenderableElementInterface
 {
-
     use AttributeFormatterTrait;
 
     /**
@@ -22,6 +22,7 @@ class Input implements RenderableElementInterface
     public function render(ElementInterface $element): string
     {
         $attributes = $element->attributes();
+        $attributes = $this->buildCssClasses($attributes, 'element', $element);
 
         return sprintf(
             '<input %s />',
diff --git a/src/View/Label.php b/src/View/Label.php
index a5cd04f..f848730 100644
--- a/src/View/Label.php
+++ b/src/View/Label.php
@@ -12,16 +12,15 @@
  */
 class Label implements RenderableElementInterface
 {
-
     use AttributeFormatterTrait;
     use AssertElementInstanceOfTrait;
 
     /**
      * @param ElementInterface|LabelAwareInterface $element
      *
+     * @return string
      * @throws InvalidClassException
      *
-     * @return string
      */
     public function render(ElementInterface $element): string
     {
@@ -32,9 +31,10 @@ public function render(ElementInterface $element): string
         }
 
         $attributes = $element->labelAttributes();
-        if (! isset($attributes['for'])) {
+        if (!isset($attributes['for'])) {
             $attributes['for'] = $element->id();
         }
+        $attributes = $this->buildCssClasses($attributes, 'label', $element);
 
         return sprintf(
             '<label %s>%s</label>',
diff --git a/src/View/Progress.php b/src/View/Progress.php
index ad2b8d8..dcd3e90 100644
--- a/src/View/Progress.php
+++ b/src/View/Progress.php
@@ -21,6 +21,8 @@ public function render(ElementInterface $element): string
     {
         $attributes = $element->attributes();
 
+        $attributes = $this->buildCssClasses($attributes, 'element', $element);
+
         return sprintf(
             '<progress %s>%s</progress>',
             $this->attributesToString($attributes),
diff --git a/src/View/Radio.php b/src/View/Radio.php
index 879e55a..2858884 100644
--- a/src/View/Radio.php
+++ b/src/View/Radio.php
@@ -4,6 +4,7 @@
 
 use ChriCo\Fields\Element\ChoiceElementInterface;
 use ChriCo\Fields\Element\ElementInterface;
+use ChriCo\Fields\Element\LabelAwareInterface;
 use ChriCo\Fields\Exception\InvalidClassException;
 
 /**
@@ -33,16 +34,17 @@ public function render(ElementInterface $element): string
 
         $html = [];
 
-        foreach ($choices as $key => $name) {
+        foreach ($choices as $key => $choice) {
             $elementAttr = $attributes;
             $elementAttr['id'] .= '_'.$key;
             $elementAttr['value'] = $key;
+            $elementAttr['disabled'] = $choice['disabled'];
             $elementAttr['checked'] = isset($selected[$key]);
 
             $label = sprintf(
                 '<label for="%s">%s</label>',
                 $this->escapeAttribute($elementAttr['id']),
-                $this->escapeHtml($name)
+                $this->escapeHtml($choice['label'])
             );
 
             $html[] = sprintf(
diff --git a/src/View/Select.php b/src/View/Select.php
index 8b0500b..cfb7f5e 100644
--- a/src/View/Select.php
+++ b/src/View/Select.php
@@ -12,22 +12,22 @@
  */
 class Select implements RenderableElementInterface
 {
-
     use AttributeFormatterTrait;
     use AssertElementInstanceOfTrait;
 
     /**
      * @param ElementInterface|ChoiceElementInterface $element
      *
+     * @return string
      * @throws InvalidClassException
      *
-     * @return string
      */
     public function render(ElementInterface $element): string
     {
         $this->assertElementIsInstanceOf($element, ChoiceElementInterface::class);
 
         $attributes = $element->attributes();
+        $attributes = $this->buildCssClasses($attributes, 'element', $element);
         unset($attributes['type'], $attributes['value']);
 
         return sprintf(
@@ -45,23 +45,24 @@ public function render(ElementInterface $element): string
      */
     protected function renderChoices(ChoiceListInterface $list, $currentValue): string
     {
-        if (! is_array($currentValue)) {
+        if (!is_array($currentValue)) {
             $currentValue = [$currentValue];
         }
 
         $selected = $list->choicesForValue($currentValue);
         $html = [];
 
-        foreach ($list->choices() as $key => $name) {
+        foreach ($list->choices() as $key => $choice) {
             $html[] = sprintf(
                 '<option %s>%s</option>',
                 $this->attributesToString(
                     [
                         'value' => $key,
                         'selected' => isset($selected[$key]),
+                        'disabled' => $choice['disabled'],
                     ]
                 ),
-                $this->escapeHtml($name)
+                $this->escapeHtml($choice['label'])
             );
         }
 
diff --git a/src/View/Textarea.php b/src/View/Textarea.php
index 29b1f2e..edbe648 100644
--- a/src/View/Textarea.php
+++ b/src/View/Textarea.php
@@ -20,6 +20,7 @@ class Textarea implements RenderableElementInterface
     public function render(ElementInterface $element): string
     {
         $attributes = $element->attributes();
+        $attributes = $this->buildCssClasses($attributes, 'element', $element);
         unset($attributes['value']);
 
         return sprintf(
diff --git a/tests/phpunit/Unit/ChoiceList/ArrayChoiceListTest.php b/tests/phpunit/Unit/ChoiceList/ArrayChoiceListTest.php
index f2f50e3..df3b167 100644
--- a/tests/phpunit/Unit/ChoiceList/ArrayChoiceListTest.php
+++ b/tests/phpunit/Unit/ChoiceList/ArrayChoiceListTest.php
@@ -29,8 +29,15 @@ public function testBasic(): void
      */
     public function testGetChoices(): void
     {
-        $expected = ['foo' => 'bar'];
-        $testee = new ArrayChoiceList($expected);
+        $input = ['foo' => 'bar'];
+        $expected = [
+            'foo' => [
+                'value' => 'foo',
+                'label' => 'bar',
+                'disabled' => false
+            ]
+        ];
+        $testee = new ArrayChoiceList($input);
 
         static::assertSame($expected, $testee->choices());
     }
@@ -49,8 +56,16 @@ public function testGetValues($input, $expected): void
 
     public function provideGetValues(): Generator
     {
-        yield 'string values' => [['foo' => 'bar'], ['foo']];
-        yield 'int values' => [[0 => 'foo', 1 => 'bar'], ['0', '1']];
+        yield 'string values' => [
+            ['foo' => 'bar'],
+            ['foo']
+        ];
+
+
+        yield 'int values' => [
+            [0 => 'foo', 1 => 'bar'],
+            ['0', '1']
+        ];
     }
 
     /**
@@ -68,20 +83,31 @@ public function testGetChoicesForValue($list, $selected, $expected): void
 
     public function provideGetChoicesForValue(): Generator
     {
+        $option1 = [
+            'value' => 'foo',
+            'label' => 'Foo',
+            'disabled' => false,
+        ];
+        $option2 = [
+            'value' => 'bar',
+            'label' => 'Bar',
+            'disabled' => false,
+        ];
+
         yield '1 selected' => [
-            ['foo' => 'bar', 'baz' => 'bam'],
+            ['foo' => $option1, 'bar' => $option2],
             ['foo'],
-            ['foo' => 'bar'],
+            ['foo' => $option1],
         ];
 
         yield 'multiple selected' => [
-            ['foo' => 'bar', 'baz' => 'bam'],
-            ['foo', 'baz'],
-            ['foo' => 'bar', 'baz' => 'bam'],
+            ['foo' => $option1, 'bar' => $option2],
+            ['foo', 'bar'],
+            ['foo' => $option1, 'bar' => $option2],
         ];
 
         yield 'nothing selected' => [
-            ['foo' => 'bar', 'baz' => 'bam'],
+            ['foo' => $option1, 'bar' => $option2],
             [],
             [],
         ];
@@ -94,7 +120,7 @@ public function provideGetChoicesForValue(): Generator
 
         yield 'empty list' => [
             [],
-            ['foo' => 'bar'],
+            ['foo'],
             [],
         ];
     }
diff --git a/tests/phpunit/Unit/ChoiceList/CallbackChoiceListTest.php b/tests/phpunit/Unit/ChoiceList/CallbackChoiceListTest.php
index 045ede2..84a404d 100644
--- a/tests/phpunit/Unit/ChoiceList/CallbackChoiceListTest.php
+++ b/tests/phpunit/Unit/ChoiceList/CallbackChoiceListTest.php
@@ -30,7 +30,13 @@ public function testBasic(): void
      */
     public function testGetChoices(): void
     {
-        $expected = ['foo' => 'bar'];
+        $expected = [
+            'foo' => [
+                'value' => 'foo',
+                'label' => 'Foo',
+                'disabled' => false,
+            ],
+        ];
 
         $callback = function () use ($expected) {
             return $expected;
diff --git a/tests/phpunit/Unit/Element/CollectionElementTest.php b/tests/phpunit/Unit/Element/CollectionElementTest.php
index 5161a40..a1269a7 100644
--- a/tests/phpunit/Unit/Element/CollectionElementTest.php
+++ b/tests/phpunit/Unit/Element/CollectionElementTest.php
@@ -105,7 +105,8 @@ public function testAddErrorsDeletaged(): void
         /** @var ErrorAwareInterface $element */
         $element = $testee->element($expected_element_name);
 
-        static::assertSame($expected_error, $element->errors());
+        static::assertCount(1, $element->errors());
+        static::assertSame(array_values($expected_error), array_values($element->errors()));
     }
 
     /**
diff --git a/tests/phpunit/Unit/ElementFactoryTest.php b/tests/phpunit/Unit/ElementFactoryTest.php
index 2ab1791..71b2a34 100644
--- a/tests/phpunit/Unit/ElementFactoryTest.php
+++ b/tests/phpunit/Unit/ElementFactoryTest.php
@@ -249,21 +249,31 @@ public function testCreateWithChoices($choices, array $expected, string $instanc
 
     public function provideCreateWithChoices(): Generator
     {
+        $choices = [
+            'foo' => [
+                'value' => 'foo',
+                'label' => 'bar',
+                'disabled' => false,
+            ],
+            'baz' => [
+                'value' => 'baz',
+                'label' => 'bam',
+                'disabled' => false,
+            ],
+        ];
+
         // normal choice list
         yield 'choice array' => [
             ['foo' => 'bar', 'baz' => 'bam'],
-            ['foo' => 'bar', 'baz' => 'bam'],
+            $choices,
             ArrayChoiceList::class,
         ];
 
-        // choice list with callback
-        $expected = ['foo' => 'bar', 'baz' => 'bam'];
-
         yield 'choices via callable' => [
-            function () use ($expected) {
-                return $expected;
+            function () use ($choices) {
+                return $choices;
             },
-            $expected,
+            $choices,
             CallbackChoiceList::class,
         ];
     }
diff --git a/tests/phpunit/Unit/View/ButtonTest.php b/tests/phpunit/Unit/View/ButtonTest.php
new file mode 100644
index 0000000..653e18c
--- /dev/null
+++ b/tests/phpunit/Unit/View/ButtonTest.php
@@ -0,0 +1,59 @@
+<?php # -*- coding: utf-8 -*-
+
+namespace ChriCo\Fields\Tests\Unit\View;
+
+use ChriCo\Fields\Element\Element;
+use ChriCo\Fields\View\Button;
+use ChriCo\Fields\View\RenderableElementInterface;
+
+class ButtonTest extends AbstractViewTestCase
+{
+    /**
+     * Basic test to check the default behavior of the class.
+     *
+     * @test
+     */
+    public function testBasic(): void
+    {
+        $testee = new Button();
+        static::assertInstanceOf(RenderableElementInterface::class, $testee);
+    }
+
+    /**
+     * @test
+     */
+    public function testRenderTypeButton(): void
+    {
+        $expectedLabel = 'some label';
+
+        $element = new Element('foo');
+        $element->withAttribute('type', 'button');
+        $element->withLabel($expectedLabel);
+
+        $output = (new Button())->render($element);
+        static::assertStringContainsString('<button', $output);
+        static::assertStringContainsString('name="foo"', $output);
+        static::assertStringContainsString('type="button"', $output);
+        static::assertStringContainsString($expectedLabel, $output);
+        static::assertStringContainsString('</button>', $output);
+    }
+
+    /**
+     * @test
+     */
+    public function testRenderTypeReset(): void
+    {
+        $expectedLabel = 'some label';
+
+        $element = new Element('foo');
+        $element->withAttribute('type', 'reset');
+        $element->withLabel($expectedLabel);
+
+        $output = (new Button())->render($element);
+        static::assertStringContainsString('<button', $output);
+        static::assertStringContainsString('name="foo"', $output);
+        static::assertStringContainsString('type="reset"', $output);
+        static::assertStringContainsString($expectedLabel, $output);
+        static::assertStringContainsString('</button>', $output);
+    }
+}
diff --git a/tests/phpunit/Unit/View/FormRowTest.php b/tests/phpunit/Unit/View/FormRowTest.php
index 25e150b..1e91120 100644
--- a/tests/phpunit/Unit/View/FormRowTest.php
+++ b/tests/phpunit/Unit/View/FormRowTest.php
@@ -30,10 +30,9 @@ public function testRender(): void
         $element->withAttribute('type', 'text');
 
         $output = (new FormRow())->render($element);
-        static::assertStringContainsString('<tr', $output);
+        static::assertStringContainsString('<div', $output);
         static::assertStringContainsString('class="form-row', $output);
-        static::assertStringContainsString('<td colspan="2">', $output);
-        static::assertStringContainsString('</tr>', $output);
+        static::assertStringContainsString('</div>', $output);
     }
 
     /**
@@ -50,10 +49,10 @@ public function testRenderWithLabel(): void
         $element->withLabel($expected_label);
 
         $output = (new FormRow())->render($element);
-        static::assertStringContainsString('<tr', $output);
+        static::assertStringContainsString('<div', $output);
         static::assertStringContainsString('class="form-row', $output);
-        static::assertStringContainsString('<th><label', $output);
-        static::assertStringContainsString($expected_label . '</label></th>', $output);
-        static::assertStringContainsString('</tr>', $output);
+        static::assertStringContainsString('<label', $output);
+        static::assertStringContainsString($expected_label . '</label>', $output);
+        static::assertStringContainsString('</div>', $output);
     }
 }