RelationOptions::proposedOptions() - Code Metrics - Inspection of "more relations" - spiral/components - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Branch — feature/pre-split (ce4b6b)

by Anton

created 2017-01-07 12:41 UTC

RelationOptions::proposedOptions() B

↳ Parent: RelationOptions

Complexity

Conditions	6
Paths	18

Size

Total Lines	55
Code Lines	23

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	6
eloc	23
nc	18
nop	1
dl	0
loc	55
rs	8.7752
c	0
b	0
f	0

How to fix Long Method

<?php
/**
 * components
 *
 * @author    Wolfy-J
 */
namespace Spiral\ORM\Helpers;

use Doctrine\Common\Inflector\Inflector;
use Spiral\ORM\Exceptions\OptionsException;
use Spiral\ORM\Record;
use Spiral\ORM\Schemas\Definitions\RelationDefinition;

/**
 * Provides ability to work with user defined relations and fill missing options based on source
 * and target contexts.
 */
class RelationOptions
{
    /**
     * @var RelationDefinition
     */
    private $definition;

    /**
     * Most of relations provides ability to specify many different configuration options, such
     * as key names, pivot table schemas, foreign key request, ability to be nullabe and etc.
     *
     * To simple schema definition in real projects we can fill some of this values automatically
     * based on some "environment" values such as parent/outer record table, role name, primary key
     * and etc.
     *
     * Example:
     * Record::INNER_KEY => '{outer:role}_{outer:primaryKey}'
     *
     * Result:
     * Outer Record is User with primary key "id" => "user_id"
     *
     * @var array
     */
    private $template;

    /**
     * Options calculated based on values provided by RelationDefinition and calculated via
     * template.
     *
     * @var array
     */
    private $options;

    /**
     * @param RelationDefinition $definition
     * @param array              $template Relation options template.
     */
    public function __construct(RelationDefinition $definition, array $template = [])
    {
        $this->definition = $definition;
        $this->template = $template;

        $this->options = $this->calculateOptions($definition->getOptions());
    }

    /**
     * Get value for a specific option. Attention, option MUST exist in template in order to
     * be retrievable.
     *
     * @param string $option
     *
     * @return mixed
     *
     * @throws OptionsException
     */
    public function define(string $option)
    {
        if (!array_key_exists($option, $this->options)) {
            throw new OptionsException("Undefined relation option '{$option}'");
        }

        return $this->options[$option];
    }

    /**
     * All relation options.
     *
     * @param array $options Options to be defined.
     *
     * @return array
     */
    public function defineMultiple(array $options): array
    {
        return array_intersect_key($this->options, array_flip($options));
    }

    /**
     * Calculate options based on given template
     *
     * @param array $userOptions Options provided by user.
     *
     * @return array Calculated options.
     */
    protected function calculateOptions(array $userOptions): array
    {
        foreach ($this->template as $property => $pattern) {
            if (isset($userOptions[$property])) {
                //Specified by user
                continue;
            }

            if (!is_string($pattern)) {
                //Some options are actually array of options
                $userOptions[$property] = $pattern;
                continue;
            }

            //Let's create option value using default proposer values
            $userOptions[$property] = \Spiral\interpolate(
                $pattern,
                $this->proposedOptions($userOptions)
            );
        }

        return $userOptions;
    }

    /**
     * Create set of options to specify missing relation definition fields.
     *
     * @param array $userOptions User options.
     *
     * @return array
     */
    protected function proposedOptions(array $userOptions): array
    {
        $source = $this->definition->sourceContext();

        $proposed = [
            //Relation name
            'relation:name'     => $this->definition->getName(),

            //Relation name in plural form
            'relation:plural'   => Inflector::pluralize($this->definition->getName()),

            //Relation name in singular form
            'relation:singular' => Inflector::singularize($this->definition->getName()),

            //Parent record role name
            'source:role'       => $source->getRole(),

            //Parent record table name
            'source:table'      => $source->getTable(),

            //Parent record primary key
            'source:primaryKey' => !empty($source->getPrimary()) ? $source->getPrimary()->getName() : '',
        ];

        //Some options may use values declared in other definition fields
        $aliases = [
            Record::OUTER_KEY   => 'outerKey',
            Record::INNER_KEY   => 'innerKey',
            Record::PIVOT_TABLE => 'pivotTable',
        ];

        foreach ($aliases as $property => $alias) {
            if (isset($userOptions[$property])) {
                //Let's create some default options based on user specified values
                $proposed['option:' . $alias] = $userOptions[$property];
            }
        }

        if (!empty($this->definition->targetContext())) {
            $target = $this->definition->targetContext();

            $proposed = $proposed + [
                    //Outer role name
                    'target:role'       => $target->getRole(),

                    //Outer record table
                    'target:table'      => $target->getTable(),

                    //Outer record primary key
                    'target:primaryKey' => !empty($target->getPrimary()) ? $target->getPrimary()->getName() : '',
                ];
        }

        return $proposed;
    }
}

1			<?php
2			/**
3			* components
4			*
5			* @author Wolfy-J
6			*/
7			namespace Spiral\ORM\Helpers;
8
9			use Doctrine\Common\Inflector\Inflector;
10			use Spiral\ORM\Exceptions\OptionsException;
11			use Spiral\ORM\Record;
12			use Spiral\ORM\Schemas\Definitions\RelationDefinition;
13
14			/**
15			* Provides ability to work with user defined relations and fill missing options based on source
16			* and target contexts.
17			*/
18			class RelationOptions
19			{
20			/**
21			* @var RelationDefinition
22			*/
23			private $definition;
24
25			/**
26			* Most of relations provides ability to specify many different configuration options, such
27			* as key names, pivot table schemas, foreign key request, ability to be nullabe and etc.
28			*
29			* To simple schema definition in real projects we can fill some of this values automatically
30			* based on some "environment" values such as parent/outer record table, role name, primary key
31			* and etc.
32			*
33			* Example:
34			* Record::INNER_KEY => '{outer:role}_{outer:primaryKey}'
35			*
36			* Result:
37			* Outer Record is User with primary key "id" => "user_id"
38			*
39			* @var array
40			*/
41			private $template;
42
43			/**
44			* Options calculated based on values provided by RelationDefinition and calculated via
45			* template.
46			*
47			* @var array
48			*/
49			private $options;
50
51			/**
52			* @param RelationDefinition $definition
53			* @param array $template Relation options template.
54			*/
55			public function __construct(RelationDefinition $definition, array $template = [])
56			{
57			$this->definition = $definition;
58			$this->template = $template;
59
60			$this->options = $this->calculateOptions($definition->getOptions());
61			}
62
63			/**
64			* Get value for a specific option. Attention, option MUST exist in template in order to
65			* be retrievable.
66			*
67			* @param string $option
68			*
69			* @return mixed
70			*
71			* @throws OptionsException
72			*/
73			public function define(string $option)
74			{
75			if (!array_key_exists($option, $this->options)) {
76			throw new OptionsException("Undefined relation option '{$option}'");
77			}
78
79			return $this->options[$option];
80			}
81
82			/**
83			* All relation options.
84			*
85			* @param array $options Options to be defined.
86			*
87			* @return array
88			*/
89			public function defineMultiple(array $options): array
90			{
91			return array_intersect_key($this->options, array_flip($options));
92			}
93
94			/**
95			* Calculate options based on given template
96			*
97			* @param array $userOptions Options provided by user.
98			*
99			* @return array Calculated options.
100			*/
101			protected function calculateOptions(array $userOptions): array
102			{
103			foreach ($this->template as $property => $pattern) {
104			if (isset($userOptions[$property])) {
105			//Specified by user
106			continue;
107			}
108
109			if (!is_string($pattern)) {
110			//Some options are actually array of options
111			$userOptions[$property] = $pattern;
112			continue;
113			}
114
115			//Let's create option value using default proposer values
116			$userOptions[$property] = \Spiral\interpolate(
117			$pattern,
118			$this->proposedOptions($userOptions)
119			);
120			}
121
122			return $userOptions;
123			}
124
125			/**
126			* Create set of options to specify missing relation definition fields.
127			*
128			* @param array $userOptions User options.
129			*
130			* @return array
131			*/
132			protected function proposedOptions(array $userOptions): array
133			{
134			$source = $this->definition->sourceContext();
135
136			$proposed = [
137			//Relation name
138			'relation:name' => $this->definition->getName(),
139
140			//Relation name in plural form
141			'relation:plural' => Inflector::pluralize($this->definition->getName()),
142
143			//Relation name in singular form
144			'relation:singular' => Inflector::singularize($this->definition->getName()),
145
146			//Parent record role name
147			'source:role' => $source->getRole(),
148
149			//Parent record table name
150			'source:table' => $source->getTable(),
151
152			//Parent record primary key
153			'source:primaryKey' => !empty($source->getPrimary()) ? $source->getPrimary()->getName() : '',
154			];
155
156			//Some options may use values declared in other definition fields
157			$aliases = [
158			Record::OUTER_KEY => 'outerKey',
159			Record::INNER_KEY => 'innerKey',
160			Record::PIVOT_TABLE => 'pivotTable',
161			];
162
163			foreach ($aliases as $property => $alias) {
164			if (isset($userOptions[$property])) {
165			//Let's create some default options based on user specified values
166			$proposed['option:' . $alias] = $userOptions[$property];
167			}
168			}
169
170			if (!empty($this->definition->targetContext())) {
171			$target = $this->definition->targetContext();
172
173			$proposed = $proposed + [
174			//Outer role name
175			'target:role' => $target->getRole(),
176
177			//Outer record table
178			'target:table' => $target->getTable(),
179
180			//Outer record primary key
181			'target:primaryKey' => !empty($target->getPrimary()) ? $target->getPrimary()->getName() : '',
182			];
183			}
184
185			return $proposed;
186			}
187			}

spiral / components

Branch — feature/pre-split (ce4b6b)

RelationOptions::proposedOptions() B

Complexity

Size

Duplication

Importance

How to fix Long Method

Long Method

Duplication Side-by-Side

Filter issues like