StoutLogic\AcfBuilder\FieldManager

Complexity

Total Complexity

31

Size/Duplication

Total Lines	216
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	3

Importance

Changes	4
Bugs	0	Features	2

16 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
A	getFields()	0	4	1
A	getCount()	0	4	1
A	pushField()	0	4	1
A	popField()	0	9	2
B	insertFields()	0	17	7
A	removeFieldAtIndex()	0	4	1
A	removeField()	0	5	1
A	replaceField()	0	6	1
A	fieldNameExists()	0	10	2
A	getField()	0	4	1
A	getFieldName()	0	12	4
A	modifyField()	0	6	1
A	validateField()	0	4	1
A	validateFieldName()	0	9	3
A	getFieldIndex()	0	10	3

<?php

namespace StoutLogic\AcfBuilder;

/**
 * Manages an array of field configs
 */
class FieldManager
{
    /**
     * Array of fields
     * @var array
     */
    private $fields;

    /**
     * @param array $fields optional default array of field configs
     */
    public function __construct($fields = [])
    {
        $this->fields = $fields;
    }

    /**
     * @return array field configs
     */
    public function getFields()
    {
        return $this->fields;
    }

    /**
     * Return int of fields
     * @return int field count
     */
    public function getCount()
    {
        return count($this->getFields());
    }

    /**
     * Add field to end of array
     * @param  array|Builder $field Field array config or Builder
     * @return void
     */
    public function pushField($field)
    {
        $this->insertFields($field, $this->getCount());

It seems like $field defined by parameter $field on line 46 can also be of type object<StoutLogic\AcfBuilder\Builder>; however, StoutLogic\AcfBuilder\FieldManager::insertFields() does only seem to accept array|object<StoutLogic\AcfBuilder\NamedBuilder>, maybe add an additional type check?

    }

    /**
     * Remove last field from end of array
     * @throws \OutOfRangeException if array is empty
     * @return array|Builder Field array config or Builder
     */
    public function popField()
    {
        if ($this->getCount() > 0) {
            $fields = $this->removeFieldAtIndex($this->getCount() - 1);
            return $fields[0];
        }

        throw new \OutOfRangeException("Can't call popField when the field count is 0");
    }

    /**
     * Insert of field at a specific index
     * @param  array|NamedBuilder $fields a single field or an array of fields
     * @param  int $index  insertion point
     * @return void
     */
    public function insertFields($fields, $index)
    {
        if (!$fields instanceof NamedBuilder && !is_array($fields)) {
            return;
        }

        // If a singular field config, put into an array of fields
        if ($fields instanceof NamedBuilder || array_key_exists('name', $fields)) {
            $fields = [$fields];
        }

        foreach ($fields as $i => $field) {
            if ($this->validateField($field)) {
                array_splice($this->fields, $index + $i, 0, [$field]);
            }
        }
    }

    /**
     * Remove a field at a specific index
     * @param  int $index
     * @return array  removed field
     */
    private function removeFieldAtIndex($index)
    {
        return array_splice($this->fields, $index, 1);
    }

    /**
     * Remove a speicifc field by name
     * @param  string $name name of the field
     * @return void
     */
    public function removeField($name)
    {
        $index = $this->getFieldIndex($name);
        $this->removeFieldAtIndex($index);
    }

    /**
     * Replace a field with a single field or array of fields
     * @param  string $name  name of field to replace
     * @param  array|Builder $field single or array of fields
     * @return void
     */
    public function replaceField($name, $field)
    {
        $index = $this->getFieldIndex($name);
        $this->removeFieldAtIndex($index);
        $this->insertFields($field, $index);

It seems like $field defined by parameter $field on line 117 can also be of type object<StoutLogic\AcfBuilder\Builder>; however, StoutLogic\AcfBuilder\FieldManager::insertFields() does only seem to accept array|object<StoutLogic\AcfBuilder\NamedBuilder>, maybe add an additional type check?

    }

    /**
     * Check to see if a field name already exists
     * @param  string $name field name
     * @return bool
     */
    public function fieldNameExists($name)
    {
        try {
            $this->getFieldIndex($name);
        } catch (FieldNotFoundException $e) {
            return false;
        }

        return true;
    }

    /**
     * Return a field by name
     * @param  string $name field name
     * @return array|Builder  Field config array or Builder
     */
    public function getField($name)
    {
        return $this->fields[$this->getFieldIndex($name)];
    }

    /**
     * Return the name given a field
     * @param  array|NamedBuilder $field
     * @return string|false field name
     */
    public function getFieldName($field)
    {
        if ($field instanceof NamedBuilder) {
            return $field->getName();
        }

        if (is_array($field) && array_key_exists('name', $field)) {
            return $field['name'];
        }

        return false;
    }

    /**
     * Modify the configuration of a field
     * @param  string $name          field name
     * @param  array $modifications  field configuration
     * @return void
     */
    public function modifyField($name, $modifications)
    {
        $field = $this->getField($name);
        $field = array_merge($field, $modifications);
        $this->replaceField($name, $field);
    }

    /**
     * Validate a field
     * @param  array|Builder $field
     * @return bool
     */
    private function validateField($field)
    {
        return $this->validateFieldName($field);

It seems like $field defined by parameter $field on line 186 can also be of type object<StoutLogic\AcfBuilder\Builder>; however, StoutLogic\AcfBuilder\FieldManager::validateFieldName() does only seem to accept array|object<StoutLogic\AcfBuilder\NamedBuilder>, maybe add an additional type check?

    }

    /**
     * Validates that a field's name doesn't already exist
     * @param  array|NamedBuilder $field
     * @throws FieldNameCollisionException when the name already exists
     * @return bool
     */
    private function validateFieldName($field)
    {
        $fieldName = $this->getFieldName($field);
        if (!$fieldName || $this->fieldNameExists($fieldName)) {

The expression $fieldName of type string|false is loosely compared to false; this is ambiguous if the string can be empty. You might want to explicitly use === false instead.

            throw new FieldNameCollisionException("Field Name: `{$fieldName}` already exists.");
        }

        return true;
    }

    /**
     * Return the index in the $this->fields array looked up by the field's name
     * @param  string $name Field Name
     * @throws FieldNotFoundException if the field name doesn't exist
     * @return int Field Index
     */
    public function getFieldIndex($name)
    {
        foreach ($this->getFields() as $index => $field) {
            if ($this->getFieldName($field) === $name) {
                return $index;
            }
        }

        throw new FieldNotFoundException("Field `{$name}` not found.");
    }
}