schema::__construct() - Code Metrics - Inspection of "Implementing storage usage when using multiselect" - flack/openpsa - Measure and Improve Code Quality continuously with Scrutinizer

Test Setup Failed

Pull Request — master (#190)

unknown

created 2017-05-30 11:47 UTC

schema::__construct() A

↳ Parent: schema

Complexity

Conditions	1
Paths	1

Size

Total Lines	5
Code Lines	3

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	3
CRAP Score	1

Importance

Changes

Metric	Value
cc	1
eloc	3
nc	1
nop	1
dl	0
loc	5
ccs	3
cts	3
cp	1
crap	1
rs	9.4285
c	0
b	0
f	0

<?php
/**
 * @copyright CONTENT CONTROL GmbH, http://www.contentcontrol-berlin.de
 */

namespace midcom\datamanager;

use midcom_error;
use Symfony\Component\Form\FormBuilderInterface;
use Symfony\Component\OptionsResolver\Options;
use Symfony\Component\OptionsResolver\OptionsResolver;
use Symfony\Component\Validator\Constraints\NotBlank;
use midcom;
use midcom_core_context;
use midcom\datamanager\extension\compat;

/**
 * Experimental schema class
 */
class schema
{
    private $defaults = array(
        'operations' => array('save' => '', 'cancel' => '')
    );

    private $config = array();

    /**
     *
     * @var string
     */
    private $name = 'default';

    public function __construct(array $config)
    {
        $this->config = array_merge($this->defaults, $config);
        $this->complete_fields();
    }

    /**
     *
     * @param string $name
     */
    public function set_name($name)
    {
        $this->name = $name;
    }

    /**
     *
     * @return string
     */
    public function get_name()
    {
        return $this->name;
    }

    /**
     *
     * @param FormBuilderInterface $builder
     * @return \Symfony\Component\Form\Form
     */
    public function build_form(FormBuilderInterface $builder)
    {
        foreach ($this->config['fields'] as $name => $config) {
            $options = array(
                'label' => $config['title'],
                'widget_config' => $config['widget_config'],
                'type_config' => $config['type_config'],
                'required' => $config['required'],
                'constraints' => $config['required'] ? array(new NotBlank()) : null,
                'dm2_type' => $config['type'],
                'start_fieldset' => $config['start_fieldset'],
                'end_fieldset' => $config['end_fieldset'],
                'index_method' => $config['index_method']
            );

            // Symfony < 2.8 compat
            if (compat::is_legacy()) {
                $options['read_only'] = $config['readonly'];
            } else {
                $options['attr']['readonly'] = $config['readonly'];
            }

            $builder->add($name, compat::get_type_name($config['widget']), $options);
        }

        $builder->add('form_toolbar', compat::get_type_name('toolbar'), array('operations' => $this->config['operations']));
        return $builder->getForm();
    }

    /**
     *
     * @return array
     */
    public function get_fields()
    {
        return $this->config['fields'];
    }

    /**
     *
     * @return \midcom_services_i18n_l10n
     */
    public function get_l10n()
    {
        // Populate the l10n_schema member
        if (array_key_exists('l10n_db', $this->config)) {
            $l10n_name = $this->config['l10n_db'];
        } else {
            $l10n_name = midcom_core_context::get()->get_key(MIDCOM_CONTEXT_COMPONENT);
        }
        if (!midcom::get()->componentloader->is_installed($l10n_name)) {
            $l10n_name = 'midcom';
        }
        return midcom::get()->i18n->get_l10n($l10n_name);
    }


    private function complete_fields()
    {
        foreach ($this->config['fields'] as $name => &$config) {
            $config = $this->resolve_field_options($config, $name);
        }
    }

    private function resolve_field_options(array $config, $name)
    {
        $resolver = new OptionsResolver();

        $resolver->setDefaults(array(
            'title' => '',
            'type' => null,
            'type_config' => array(),
            'widget' => null,
            'widget_config' => array(),
            'required' => false,
            'readonly' => false,
            'default' => null,
            'storage' => '__UNSET__',
            'index_method' => 'auto',
            'start_fieldset' => null,
            'end_fieldset' => null,
            'validation' => array()
        ));

        $normalize_widget = function (Options $options, $value) {
            if (   $value == 'images'
                || $value == 'downloads') {
                return 'subform';
            }
            return $value;
        };

        $normalize_storage = function (Options $options, $value) use ($name) {
            $default = array(
                'location' => 'parameter',
                'domain' => 'midcom.helper.datamanager2',
                'name' => $name
            );
            if ($value === '__UNSET__') {
                return $default;
            }
            if ($value === null) {

                if($options['type'] === 'privilege')
                {
                    return array(
                        'location' => 'privilege',
                        'name' => $name
                    );
                }
                return null;
            }
            if (is_string($value)) {
                if ($value === 'metadata') {
                    return array('location' => $value, 'name' => $name);
                }
                if ($value === 'parameter') {
                    return $default;
                }
                return array('location' => $value);
            }
            if (strtolower($value['location']) === 'parameter') {
                $value['location'] = strtolower($value['location']);
                if (!array_key_exists('domain', $value)) {
                    $value['domain'] = 'midcom.helper.datamanager2';
                }
            }
            if (strtolower($value['location']) === 'configuration') {
                $value['location'] = 'parameter';
            }
            return $value;
        };

        $normalize_validation = function (Options $options, $config) {
            $validation = array();
            if (array_key_exists('validation',(array) $config)) {
                $validation = (array) $config['validation'];
            }

            foreach ($validation as $key => $rule) {
                if (!is_array($rule)) {
                    $rule = array('type' => $rule);
                } elseif (!array_key_exists('type', $rule)) {
                    throw new midcom_error("Missing validation rule type for rule {$key} on field {$config['name']}, this is a required option.");
                } elseif (   $rule['type'] == 'compare'
                          && !array_key_exists('compare_with', $rule)) {
                    throw new midcom_error("Missing compare_with option for compare type rule {$key} on field {$config['name']}, this is a required option.");
                }

                $defaults = array(
                    'message' => "validation failed: {$rule['type']}",
                    'format' => ''
                );

                $validation[$key] = array_merge($defaults, $rule);
            }
            return $validation;
        };

        $resolver->setNormalizer('storage', $normalize_storage);
        $resolver->setNormalizer('widget', $normalize_widget);
        $resolver->setNormalizer('validation', $normalize_validation);

        return $resolver->resolve($config);
    }
}


1		<?php
2		/**
3		* @copyright CONTENT CONTROL GmbH, http://www.contentcontrol-berlin.de
4		*/
5
6		namespace midcom\datamanager;
7
8		use midcom_error;
9		use Symfony\Component\Form\FormBuilderInterface;
10		use Symfony\Component\OptionsResolver\Options;
11		use Symfony\Component\OptionsResolver\OptionsResolver;
12		use Symfony\Component\Validator\Constraints\NotBlank;
13		use midcom;
14		use midcom_core_context;
15		use midcom\datamanager\extension\compat;
16
17		/**
18		* Experimental schema class
19		*/
20		class schema
21		{
22		private $defaults = array(
23		'operations' => array('save' => '', 'cancel' => '')
24		);
25
26		private $config = array();
27
28		/**
29		*
30		* @var string
31		*/
32		private $name = 'default';
33	5
34		public function __construct(array $config)
35	5	{
36	5	$this->config = array_merge($this->defaults, $config);
37	5	$this->complete_fields();
38		}
39
40		/**
41		*
42		* @param string $name
43	1	*/
44		public function set_name($name)
45	1	{
46	1	$this->name = $name;
47		}
48
49		/**
50		*
51		* @return string
52	1	*/
53		public function get_name()
54	1	{
55		return $this->name;
56		}
57
58		/**
59		*
60		* @param FormBuilderInterface $builder
61		* @return \Symfony\Component\Form\Form
62	1	*/
63		public function build_form(FormBuilderInterface $builder)
64	1	{
65		foreach ($this->config['fields'] as $name => $config) {
66		$options = array(
67		'label' => $config['title'],
68		'widget_config' => $config['widget_config'],
69		'type_config' => $config['type_config'],
70		'required' => $config['required'],
71		'constraints' => $config['required'] ? array(new NotBlank()) : null,
72		'dm2_type' => $config['type'],
73		'start_fieldset' => $config['start_fieldset'],
74		'end_fieldset' => $config['end_fieldset'],
75		'index_method' => $config['index_method']
76		);
77
78		// Symfony < 2.8 compat
79		if (compat::is_legacy()) {
80		$options['read_only'] = $config['readonly'];
81		} else {
82		$options['attr']['readonly'] = $config['readonly'];
83		}
84
85		$builder->add($name, compat::get_type_name($config['widget']), $options);
86		}
87	1
88	1	$builder->add('form_toolbar', compat::get_type_name('toolbar'), array('operations' => $this->config['operations']));
89		return $builder->getForm();
90		}
91
92		/**
93		*
94		* @return array
95	5	*/
96		public function get_fields()
97	5	{
98		return $this->config['fields'];
99		}
100
101		/**
102		*
103		* @return \midcom_services_i18n_l10n
104	1	*/
105		public function get_l10n()
106		{
107	1	// Populate the l10n_schema member
108		if (array_key_exists('l10n_db', $this->config)) {
109		$l10n_name = $this->config['l10n_db'];
110	1	} else {
111		$l10n_name = midcom_core_context::get()->get_key(MIDCOM_CONTEXT_COMPONENT);
112	1	}
113	1	if (!midcom::get()->componentloader->is_installed($l10n_name)) {
114		$l10n_name = 'midcom';
115	1	}
116		return midcom::get()->i18n->get_l10n($l10n_name);
117		}
118
119	5
120		private function complete_fields()
121	5	{
122	4	foreach ($this->config['fields'] as $name => &$config) {
123		$config = $this->resolve_field_options($config, $name);
124	5	}
125		}
126	4
127		private function resolve_field_options(array $config, $name)
128	4	{
129		$resolver = new OptionsResolver();
130	4
131	4	$resolver->setDefaults(array(
132		'title' => '',
133		'type' => null,
134		'type_config' => array(),
135		'widget' => null,
136		'widget_config' => array(),
137		'required' => false,
138		'readonly' => false,
139		'default' => null,
140		'storage' => '__UNSET__',
141		'index_method' => 'auto',
142		'start_fieldset' => null,
143		'end_fieldset' => null,
144		'validation' => array()
145		));
146	4
147	4	$normalize_widget = function (Options $options, $value) {
148	1	if ( $value == 'images'
149		\|\| $value == 'downloads') {
150	3	return 'subform';
151	4	}
152		return $value;
153	4	};
154
155	4	$normalize_storage = function (Options $options, $value) use ($name) {
156	4	$default = array(
157	4	'location' => 'parameter',
158		'domain' => 'midcom.helper.datamanager2',
159	4	'name' => $name
160		);
161		if ($value === '__UNSET__') {
162	4	return $default;
163	1	}
164		if ($value === null) {
165	3
166	1	if($options['type'] === 'privilege')
167		{
168		return array(
169	1	'location' => 'privilege',
170	1	'name' => $name
171		);
172		}
173		return null;
174	2	}
175	2	if (is_string($value)) {
176	2	if ($value === 'metadata') {
177		return array('location' => $value, 'name' => $name);
178		}
179		if ($value === 'parameter') {
180	2	return $default;
181		}
182		return array('location' => $value);
183	2	}
184	4	if (strtolower($value['location']) === 'parameter') {
185		$value['location'] = strtolower($value['location']);
186	4	if (!array_key_exists('domain', $value)) {
187	4	$value['domain'] = 'midcom.helper.datamanager2';
188		}
189	4	}
190		if (strtolower($value['location']) === 'configuration') {
191		$value['location'] = 'parameter';
192		}
193		return $value;
194		};
195
196		$normalize_validation = function (Options $options, $config) {
197		$validation = array();
198		if (array_key_exists('validation',(array) $config)) {
199		$validation = (array) $config['validation'];
200		}
201
202		foreach ($validation as $key => $rule) {
203		if (!is_array($rule)) {
204		$rule = array('type' => $rule);
205		} elseif (!array_key_exists('type', $rule)) {
206		throw new midcom_error("Missing validation rule type for rule {$key} on field {$config['name']}, this is a required option.");
207		} elseif ( $rule['type'] == 'compare'
208		&& !array_key_exists('compare_with', $rule)) {
209		throw new midcom_error("Missing compare_with option for compare type rule {$key} on field {$config['name']}, this is a required option.");
210		}
211
212		$defaults = array(
213		'message' => "validation failed: {$rule['type']}",
214		'format' => ''
215		);
216
217		$validation[$key] = array_merge($defaults, $rule);
218		}
219		return $validation;
220		};
221
222		$resolver->setNormalizer('storage', $normalize_storage);
223		$resolver->setNormalizer('widget', $normalize_widget);
224		$resolver->setNormalizer('validation', $normalize_validation);
225
226		return $resolver->resolve($config);
227		}
228		}
229

flack / openpsa

Pull Request — master (#190)

schema::__construct() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like