Form::addOutput() - Code Metrics - Inspection of "rename files and namespace" - canax/htmlform - Measure and Improve Code Quality continuously with Scrutinizer

Test Failed
Push — master ( 194522...eda1b6 )

by Mikael
created 2017-08-15 08:11 UTC
Form::addOutput() A

↳ Parent: Form
Complexity

Conditions	2
Paths	2
Size

Total Lines	10
Code Lines	7
Duplication

Lines	0
Ratio	0 %
Importance

Changes
Metric	Value
cc	2
eloc	7
nc	2
nop	1
dl	0
loc	10
rs	9.4285
c	0
b	0
f	0
<?php

namespace Anax\HTMLForm;

/**
 * A utility class to easy creating and handling of forms
 */
class Form implements \ArrayAccess
{

    /**
     * Properties
     */
    public $form;     // array with settings for the form
    public $elements; // array with all form elements
    public $output;   // array with messages to display together with the form
    public $session;  // array with key values for the session



    /**
     * Constructor
     *
     * @param array $form     details for the form
     * @param array $elements all the elements
     */
    public function __construct($form = [], $elements = [])
    {
        $this->create($form, $elements);
    }



    /**
     * Implementing ArrayAccess for this->elements
     */
    public function offsetSet($offset, $value)
    {
        if (is_null($offset)) {

            $this->elements[] = $value;
        } else {
            $this->elements[$offset] = $value;
        }
    }
    
    public function offsetExists($offset)
    {
        return isset($this->elements[$offset]);
    }
    
    public function offsetUnset($offset)
    {
        unset($this->elements[$offset]);
    }
    
    public function offsetGet($offset)
    {
        return isset($this->elements[$offset])
            ? $this->elements[$offset]
            : null;
    }



    /**
     * Add a form element
     *
     * @param array $form     details for the form
     * @param array $elements all the elements
     *
     * @return $this
     */
    public function create($form = [], $elements = [])
    {
        $defaults = [
            // Always have a id for the form
            "id" => "anax/htmlform",
        ];
        $this->form = array_merge($defaults, $form);

        $this->elements = [];
        if (!empty($elements)) {
            foreach ($elements as $key => $element) {
                $this->elements[$key] = FormElement::Create($key, $element);
            }
        }

        $this->output = [];

        // Setting keys used in the session
        $generalKey = "anax/htmlform-" . $this->form["id"] . "#";
        $this->session = [
            "save"      => $generalKey . "save",
            "output"    => $generalKey . "output",
            "failed"    => $generalKey . "failed",
            "remember"  => $generalKey . "remember",
        ];

        return $this;
    }



    /**
     * Add a form element
     *
     * @param FormElement $element the formelement to add.
     *
     * @return $this
     */
    public function addElement($element)
    {
        $this[$element['name']] = $element;
        return $this;
    }



    /**
     * Remove an form element
     *
     * @param string $name the name of the element to remove from the form.
     *
     * @return $this
     */
    public function removeElement($name)
    {
        unset($this->elements[$name]);
        return $this;
    }



    /**
     * Set validation to a form element
     *
     * @param string $element the name of the formelement to add validation rules to.
     * @param array  $rules   array of validation rules.
     *
     * @return $this
     */
    public function setValidation($element, $rules)
    {
        $this[$element]['validation'] = $rules;
        return $this;
    }



    /**
     * Add output to display to the user what happened whith the form.
     *
     * @param string $str the string to add as output.
     *
     * @return $this.

     */
    public function addOutput($str)
    {
        $key = $this->session["output"];
        if (isset($_SESSION[$key])) {
            $_SESSION[$key] .= " $str";
        } else {
            $_SESSION[$key] = $str;
        }
        return $this;
    }



    /**
     * Get value of a form element
     *
     * @param string $element the name of the formelement.
     *
     * @return mixed the value of the element.
     */
    public function value($element)
    {
        return $this[$element]->value();
    }



    /**
     * Return HTML for the form or the formdefinition.
     *
     * @param array $options with options affecting the form output.
     *
     * @return string with HTML for the form.
     */
    public function getHTML($options = [])
    {
        $defaults = [
            // Only return the start of the form element
            'start'         => false,
            
            // Layout all elements in one column
            'columns'       => 1,
            
            // Layout consequtive buttons as one element wrapped in <p>
            'use_buttonbar' => true,

            // Wrap fields within <fieldset>
            'use_fieldset'  => true,

            // Use legend for fieldset
            'legend'        => isset($this->form['legend']) ?
                $this->form['legend']
                : null,
        ];
        $options = array_merge($defaults, $options);

        $form = array_merge($this->form, $options);
        $id      = isset($form['id'])      ? " id='{$form['id']}'" : null;
        $class   = isset($form['class'])   ? " class='{$form['class']}'" : null;
        $name    = isset($form['name'])    ? " name='{$form['name']}'" : null;
        $action  = isset($form['action'])  ? " action='{$form['action']}'" : null;
        $method  = isset($form['method'])  ? " method='{$form['method']}'" : " method='post'";
        $enctype = isset($form['enctype']) ? " enctype='{$form['enctype']}'" : null;
        $cformId = isset($form['id'])      ? "{$form['id']}" : null;

        if ($options['start']) {
            return "<form{$id}{$class}{$name}{$action}{$method}>\n";
        }

        $fieldsetStart  = '<fieldset>';
        $legend         = null;
        $fieldsetEnd    = '</fieldset>';
        if (!$options['use_fieldset']) {
            $fieldsetStart = $fieldsetEnd = null;
        }

        if ($options['use_fieldset'] && $options['legend']) {
            $legend = "<legend>{$options['legend']}</legend>";
        }

        $elementsArray  = $this->GetHTMLForElements($options);
        $elements       = $this->GetHTMLLayoutForElements($elementsArray, $options);
        $output         = $this->GetOutput();

        $html = <<< EOD
\n<form{$id}{$class}{$name}{$action}{$method}{$enctype}>
<input type="hidden" name="anax/htmlform-id" value="$cformId" />
{$fieldsetStart}
{$legend}
{$elements}
{$output}
{$fieldsetEnd}
</form>\n
EOD;

        return $html;
    }



    /**
     * Return HTML for the elements
     *
     * @param array $options with options affecting the form output.
     *
     * @return array with HTML for the formelements.
     */
    public function getHTMLForElements($options = [])
    {
        $defaults = [
            'use_buttonbar' => true,
        ];
        $options = array_merge($defaults, $options);

        $elements = array();
        reset($this->elements);
        while (list($key, $element) = each($this->elements)) {
<?php

function returnThreeValues() {
    return array('a', 'b', 'c');
}

list($a, $b, $c) = returnThreeValues();

print $a . " - " . $c;
            
            if (in_array($element['type'], array('submit', 'reset', 'button'))
                && $options['use_buttonbar']
            ) {

                // Create a buttonbar
                $name = 'buttonbar';
                $html = "<p class='buttonbar'>\n" . $element->GetHTML() . '&nbsp;';

                // Get all following submits (and buttons)
                while (list($key, $element) = each($this->elements)) {
<?php

function returnThreeValues() {
    return array('a', 'b', 'c');
}

list($a, $b, $c) = returnThreeValues();

print $a . " - " . $c;
                    if (in_array($element['type'], array('submit', 'reset', 'button'))) {
                        $html .= $element->GetHTML();
                    } else {
                        prev($this->elements);
                        break;
                    }
                }
                $html .= "\n</p>";

            } else {

                // Just add the element
                $name = $element['name'];
                $html = $element->GetHTML();
            }

            $elements[] = array('name'=>$name, 'html'=> $html);
        }

        return $elements;
    }




    /**
     * Place the elements according to a layout and return the HTML
     *
     * @param array $elements as returned from GetHTMLForElements().
     * @param array $options  with options affecting the layout.
     *
     * @return array with HTML for the formelements.
     */
    public function getHTMLLayoutForElements($elements, $options = [])
    {
        $defaults = [
            'columns' => 1,
            'wrap_at_element' => false,  // Wraps column in equal size or at the set number of elements
        ];
        $options = array_merge($defaults, $options);

        $html = null;
        if ($options['columns'] === 1) {

            foreach ($elements as $element) {
                $html .= $element['html'];
            }

        } elseif ($options['columns'] === 2) {

            $buttonbar = null;
            $col1 = null;
            $col2 = null;

            $e = end($elements);
            if ($e['name'] == 'buttonbar') {
                $e = array_pop($elements);
                $buttonbar = "<div class='cform-buttonbar'>\n{$e['html']}</div>\n";
            }

            $size = count($elements);
            $wrapAt = $options['wrap_at_element'] ? $options['wrap_at_element'] : round($size/2);
            for ($i=0; $i<$size; $i++) {
                if ($i < $wrapAt) {
                    $col1 .= $elements[$i]['html'];
                } else {
                    $col2 .= $elements[$i]['html'];
                }
            }

            $html = <<<EOD
<div class='cform-columns-2'>
<div class='cform-column-1'>
{$col1}
</div>
<div class='cform-column-2'>
{$col2}
</div>
{$buttonbar}</div>
EOD;
        }

        return $html;
    }



    /**
     * Get an array with all elements that failed validation together with their id and validation message.
     *
     * @return array with elements that failed validation.
     */
    public function getValidationErrors()
    {
        $errors = [];
        foreach ($this->elements as $name => $element) {
            if ($element['validation-pass'] === false) {
                $errors[$name] = [
                    'id' => $element->GetElementId(),
                    'label' => $element['label'],
                    'message' => implode(' ', $element['validation-messages'])
                ];
            }
        }
        return $errors;
    }



    /**
     * Get output messages as <output>.
     *
     * @return string|null with the complete <output> element or null if no output.
     */
    public function getOutput()
    {
        return !empty($this->output)
            ? "<output>{$this->output}</output>"
            : null;
    }



    /**
     * Init all element with values from session, clear all and fill in with values from the session.
     *
     * @param array $values retrieved from session
     *
     * @return void
     */
    protected function initElements($values)
    {
        // First clear all
        foreach ($this->elements as $key => $val) {
            // Do not reset value for buttons
            if (in_array($this[$key]['type'], array('submit', 'reset', 'button'))) {
                continue;
            }

            // Reset the value
            $this[$key]['value'] = null;

            // Checkboxes must be cleared
            if (isset($this[$key]['checked'])) {
                $this[$key]['checked'] = false;
            }
        }

        // Now build up all values from $values (session)
        foreach ($values as $key => $val) {

            // Take care of arrays as values (multiple-checkbox)
            if (isset($val['values'])) {
                $this[$key]['checked'] = $val['values'];
                //$this[$key]['values']  = $val['values'];
            } elseif (isset($val['value'])) {
                $this[$key]['value'] = $val['value'];
            }

            if ($this[$key]['type'] === 'checkbox') {
                $this[$key]['checked'] = true;
            } elseif ($this[$key]['type'] === 'radio') {
                $this[$key]['checked'] = $val['value'];
            }

            // Keep track on validation messages if set
            if (isset($val['validation-messages'])) {
                $this[$key]['validation-messages'] = $val['validation-messages'];
                $this[$key]['validation-pass'] = false;
            }
        }
    }



    /**
     * Check if a form was submitted and perform validation and call callbacks.
     * The form is stored in the session if validation or callback fails. The page should then be redirected
     * to the original form page, the form will populate from the session and should be rendered again.
     * Form elements may remember their value if 'remember' is set and true.
     *
     * @param callable $callIfSuccess handler to call if function returns true.
     * @param callable $callIfFail    handler to call if function returns true.
     *
     * @return boolean|null $callbackStatus if submitted&validates, false if not validate, null if not submitted.
     *         If submitted the callback function will return the actual value which should be true or false.
     */
    public function check($callIfSuccess = null, $callIfFail = null)
    {
        $remember = null;
        $validates = null;
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}
        $callbackStatus = null;
        $values = [];

        // Remember output messages in session
        $output = $this->session["output"];
        if (isset($_SESSION[$output])) {
            $this->output = $_SESSION[$output];
            unset($_SESSION[$output]);
        }

        // Check if this was a post request
        if ($_SERVER["REQUEST_METHOD"] !== "POST") {
            // Its not posted, but check if values should be used from session
            $failed   = $this->session["failed"];
            $remember = $this->session["remember"];
            $save     = $this->session["save"];
            
            if (isset($_SESSION[$failed])) {

                // Read form data from session if the previous post failed during validation.
                $this->InitElements($_SESSION[$failed]);
                unset($_SESSION[$failed]);

            } elseif (isset($_SESSION[$remember])) {

                // Read form data from session if some form elements should be remembered
                foreach ($_SESSION[$remember] as $key => $val) {
                    $this[$key]['value'] = $val['value'];
                }
                unset($_SESSION[$remember]);

            } elseif (isset($_SESSION[$save])) {

                // Read form data from session,
                // useful during test where the original form is displayed with its posted values
                $this->InitElements($_SESSION[$save]);
                unset($_SESSION[$save]);
            }
            
            return null;
        }
        $request = $_POST;

        // Check if its a form we are dealing with
        if (!isset($request["anax/htmlform-id"])) {
            return null;
        }

        // Check if its this form that was posted
        if ($this->form["id"] !== $request["anax/htmlform-id"]) {
            return null;
        }

        // This form was posted, process it
        if (isset($_SESSION[$this->session["failed"]])) {
            unset($_SESSION[$this->session["failed"]]);
        }
        
        $validates = true;
        foreach ($this->elements as $element) {

            $elementName = $element['name'];
            $elementType = $element['type'];

            // The form element has a value set
            if (isset($request[$elementName])) {

                // Multiple choices comes in the form of an array
                if (is_array($request[$elementName])) {
                    $values[$elementName]['values'] = $element['checked'] = $request[$elementName];
                } else {
                    $values[$elementName]['value'] = $element['value'] = $request[$elementName];
                }

                // If the element is a password, do not remember.
                if ($elementType === 'password') {
                    $values[$elementName]['value'] = null;
                }

                // If the element is a checkbox, set its value of checked.
                if ($elementType === 'checkbox') {
                    $element['checked'] = true;
                }

                // If the element is a radio, set the value to checked.
                if ($elementType === 'radio') {
                    $element['checked'] = $element['value'];
                }

                // Do validation of form element
                if (isset($element['validation'])) {


                    $element['validation-pass'] = $element->Validate($element['validation'], $this);

                    if ($element['validation-pass'] === false) {

                        $values[$elementName] = [
                            'value' => $element['value'],
                            'validation-messages' => $element['validation-messages']
                        ];
                        $validates = false;

                    }
                }

                // Hmmm.... Why did I need this remember thing?
                if (isset($element['remember'])
                    && $element['remember']
                ) {
                    $values[$elementName] = ['value' => $element['value']];
                    $remember = true;
                }

                // Carry out the callback if the form element validates
                // Hmmm, what if the element with the callback is not the last element?
                if (isset($element['callback'])
                    && $validates
                ) {

                    if (isset($element['callback-args'])) {

                        $callbackStatus = call_user_func_array(
                            $element['callback'],
                            array_merge([$this]),
                            $element['callback-args']
                        );

                    } else {

                        $callbackStatus = call_user_func($element['callback'], $this);
                    }
                }

            } else {

                // The form element has no value set

                // Set element to null, then we know it was not set.
                //$element['value'] = null;
                //echo $element['type'] . ':' . $elementName . ':' . $element['value'] . '<br>';

                // If the element is a checkbox, clear its value of checked.
                if ($element['type'] === 'checkbox'
                    || $element['type'] === 'checkbox-multiple'
                ) {

                    $element['checked'] = false;
                }

                // Do validation even when the form element is not set?
                // Duplicate code, revise this section and move outside
                // this if-statement?
                if (isset($element['validation'])) {


                    $element['validation-pass'] = $element->Validate($element['validation'], $this);

                    if ($element['validation-pass'] === false) {

                        $values[$elementName] = [
                            'value' => $element['value'], 'validation-messages' => $element['validation-messages']
                        ];
                        $validates = false;
                    }
                }
            }
        }

        // Prepare if data should be stored in the session during redirects
        // Did form validation or the callback fail?
        if ($validates === false
            || $callbackStatus === false
        ) {

            $_SESSION[$this->session["failed"]] = $values;

        } elseif ($remember) {

            // Hmmm, why do I want to use this
            $_SESSION[$this->session["remember"]] = $values;
        }

        if (isset($this->saveInSession) && $this->saveInSession) {


            // Remember all posted values
            $_SESSION[$this->session["save"]] = $values;
        }

        // Lets se what the return value should be
        $ret = $validates
            ? $callbackStatus
            : $validates;


        if ($ret === true && isset($callIfSuccess)) {

            // Use callback for success, if defined
            if (is_callable($callIfSuccess)) {
                call_user_func_array($callIfSuccess, [$this]);
            } else {
                throw new \Exception("Form, success-method is not callable.");
            }

        } elseif ($ret === false && isset($callIfFail)) {

            // Use callback for fail, if defined
            if (is_callable($callIfFail)) {
                call_user_func_array($callIfFail, [$this]);
            } else {
                throw new \Exception("Form, success-method is not callable.");
            }
        }

        return $ret;
    }
}

canax / htmlform

Push — master ( 194522...eda1b6 )

Form::addOutput() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like
