MetaBundle::normalizeMetaBundleData() - Code Metrics - nystudio107/craft-seomatic - Measure and Improve Code Quality continuously with Scrutinizer

MetaBundle::normalizeMetaBundleData() F
last analyzed 2025-10-23 20:51 UTC

↳ Parent: MetaBundle
Complexity

Conditions	15
Paths	1632
Size

Total Lines	80
Code Lines	50
Duplication

Lines	0
Ratio	0 %
Code Coverage

Tests	0
CRAP Score	240
Importance

Changes	2
Bugs	1	Features	0
Metric	Value
eloc	50
dl	0
loc	80
ccs	0
cts	51
cp	0
rs	1.7499
c	2
b	1
f	0
cc	15
nc	1632
nop	1
crap	240
How to fix Long Method Complexity

<?php
/**
 * SEOmatic plugin for Craft CMS 3.x
 *
 * A turnkey SEO implementation for Craft CMS that is comprehensive, powerful,
 * and flexible
 *
 * @link      https://nystudio107.com
 * @copyright Copyright (c) 2017 nystudio107
 */

namespace nystudio107\seomatic\models;

use craft\behaviors\EnvAttributeParserBehavior;
use craft\helpers\Json as JsonHelper;
use craft\validators\ArrayValidator;
use craft\validators\DateTimeValidator;
use DateTime;
use nystudio107\seomatic\base\FluentModel;
use nystudio107\seomatic\base\MetaContainer;
use nystudio107\seomatic\helpers\ArrayHelper;
use nystudio107\seomatic\helpers\MetaValue as MetaValueHelper;
use nystudio107\seomatic\Seomatic;
use nystudio107\seomatic\variables\SeomaticVariable;
use yii\behaviors\AttributeTypecastBehavior;
use function is_array;
use function is_string;

/**
 * @author    nystudio107
 * @package   Seomatic
 * @since     3.0.0
 */
class MetaBundle extends FluentModel
{
    // Properties
    // =========================================================================

    /**
     * @var string
     */
    public $bundleVersion;

    /**
     * @var string
     */
    public $sourceBundleType;

    /**
     * @var int
     */
    public $sourceId;

    /**
     * @var string
     */
    public $sourceName;

    /**
     * @var string
     */
    public $sourceHandle;

    /**
     * @var string
     */
    public $sourceType;

    /**
     * @var int|null
     */
    public $typeId;

    /**
     * @var string
     */
    public $sourceTemplate;

    /**
     * @var int
     */
    public $sourceSiteId;

    /**
     * @var array
     */
    public $sourceAltSiteSettings = [];

    /**
     * @var DateTime
     */
    public $sourceDateUpdated;

    /**
     * @var MetaGlobalVars|array|null
     */
    public $metaGlobalVars;

    /**
     * @var MetaSiteVars|array|null
     */
    public $metaSiteVars;

    /**
     * @var MetaSitemapVars|array|null
     */
    public $metaSitemapVars;

    /**
     * @var MetaContainer[]|array|null
     */
    public $metaContainers;

    /**
     * @var array
     */
    public $redirectsContainer;

    /**
     * @var FrontendTemplateContainer|array|null
     */
    public $frontendTemplatesContainer;

    /**
     * @var MetaBundleSettings|array|null
     */
    public $metaBundleSettings;

    // Methods
    // =========================================================================

    /**
     * Create a new meta bundle
     *
     * @param array $config
     * @param bool $parse Whether the resulting metabundle should be parsed
     *
     * @return null|MetaBundle
     */
    public static function create(array $config = [], bool $parse = true)
    {
        self::cleanProperties(__CLASS__, $config);
        $model = new MetaBundle($config);
        $model->normalizeMetaBundleData($parse);

        return $model;
    }

    /**
     * Normalizes the meta bundles’s data for use.
     *
     * This is called after meta bundle data is loaded, to allow it to be
     * parsed, models instantiated, etc.
     *
     * @param bool $parse Whether the resulting metabundle should be parsed
     */
    public function normalizeMetaBundleData(bool $parse = true)
    {
        // Decode any JSON data
        $properties = $this->getAttributes();
        foreach ($properties as $property => $value) {
            if (!empty($value) && is_string($value)) {
                $this->$property = JsonHelper::decodeIfJson($value);
            }
        }

        // Meta global variables
        if (is_array($this->metaGlobalVars)) {
            $this->metaGlobalVars = MetaGlobalVars::create($this->metaGlobalVars);
        }
        // Meta site variables
        if (is_array($this->metaSiteVars)) {
            $this->metaSiteVars = MetaSiteVars::create($this->metaSiteVars);
        }
        // Meta sitemap variables
        if (is_array($this->metaSitemapVars)) {
            $this->metaSitemapVars = MetaSitemapVars::create($this->metaSitemapVars);
        }
        // Meta bundle settings
        if (is_array($this->metaBundleSettings)) {
            $this->metaBundleSettings = MetaBundleSettings::create($this->metaBundleSettings);
        }
        // Frontend templates
        if (is_array($this->frontendTemplatesContainer)) {
            $this->frontendTemplatesContainer = FrontendTemplateContainer::create($this->frontendTemplatesContainer);
        }
        // Create our variable so that meta containers can be parsed based on dynamic values
        // Make sure Twig is loaded and instantiated first by priming the pump
        if ($parse) {
            MetaValueHelper::parseString('{{ "prime" }}');
            $oldSeomaticVariable = Seomatic::$seomaticVariable;
            if (Seomatic::$seomaticVariable === null) {
                Seomatic::$seomaticVariable = new SeomaticVariable();
            }
            $oldMeta = Seomatic::$seomaticVariable->meta;
            $oldSite = Seomatic::$seomaticVariable->site;
            $oldLoadingContainers = Seomatic::$loadingMetaContainers;
            $oldPreviewingMetaContainers = Seomatic::$previewingMetaContainers;
            Seomatic::$loadingMetaContainers = false;
            Seomatic::$previewingMetaContainers = false;
            // Merge these global vars with the MetaContainers global vars
            $globalVars = [];
            if (Seomatic::$plugin->metaContainers->metaGlobalVars !== null) {
                $globalVars = Seomatic::$plugin->metaContainers->metaGlobalVars->getAttributes();
            }
            $thisGlobalVars = $this->metaGlobalVars->getAttributes();
            $thisGlobalVars = $this->metaGlobalVars->getAttributes();
            $thisGlobals = MetaGlobalVars::create(ArrayHelper::merge($globalVars, $thisGlobalVars));
            // Merge these site vars with the MetaContainers site vars
            $siteVars = [];
            if (Seomatic::$plugin->metaContainers->metaSiteVars !== null) {
                $siteVars = Seomatic::$plugin->metaContainers->metaSiteVars->getAttributes();
            }
            $thisSiteVars = $this->metaSiteVars->getAttributes();
            $thisSiteVars = $this->metaSiteVars->getAttributes();
            $thisSite = MetaSiteVars::create(ArrayHelper::merge($siteVars, $thisSiteVars));
            Seomatic::$seomaticVariable->meta = $thisGlobals;
            Seomatic::$seomaticVariable->site = $thisSite;
            MetaValueHelper::cache();
            Seomatic::$previewingMetaContainers = $oldPreviewingMetaContainers;

            // Meta containers
            if (!empty($this->metaContainers)) {
                $metaContainers = $this->metaContainers;
                $this->metaContainers = [];
                foreach ($metaContainers as $key => $metaContainer) {
                    /** @var MetaContainer $containerClass */
                    $containerClass = $metaContainer['class'];
                    /**  @var array $metaContainer */
                    $this->metaContainers[$key] = $containerClass::create($metaContainer);
                }
            }
            // Restore the $seomaticVariable
            Seomatic::$loadingMetaContainers = $oldLoadingContainers;
            Seomatic::$seomaticVariable->meta = $oldMeta;
            Seomatic::$seomaticVariable->site = $oldSite;
            Seomatic::$seomaticVariable = $oldSeomaticVariable;
            MetaValueHelper::cache();
        }
    }

    /**
     * @inheritdoc
     */
    public function datetimeAttributes(): array
    {
        $names = parent::datetimeAttributes();
        $names[] = 'sourceDateUpdated';

        return $names;
    }

    /**
     * Validation rules
     * @return array the validation rules
     */
    public function rules(): array
    {
        $rules = [
            [
                [
                    'bundleVersion',
                    'sourceType',
                    'sourceName',
                    'sourceHandle',
                    'sourceTemplate',
                    'sourceType',
                ],
                'string',
            ],
            [
                [
                    'sourceId',
                    'sourceSiteId',
                    'typeId',
                ],
                'number',
                'skipOnEmpty' => true,
            ],
            [
                [
                    'sourceDateUpdated',
                ],
                DateTimeValidator::class,
            ],
            [
                [
                    'sourceAltSiteSettings',
                ],
                'safe',
            ],
            [
                [
                    'metaContainers',
                    'redirectsContainer',
                ],
                ArrayValidator::class,
            ],
            [
                [
                    'metaGlobalVars',
                    'metaSiteVars',
                    'metaSitemapVars',
                    'metaBundleSettings',
                    'frontendTemplatesContainer',
                ],
                'safe',
            ],
        ];

        return $rules;
    }

    /**
     * @return array
     */
    public function behaviors()
    {
        $craft31Behaviors = [];
        if (Seomatic::$craft31) {
            $craft31Behaviors = [
                'parser' => [
                    'class' => EnvAttributeParserBehavior::class,
                    'attributes' => [
                    ],
                ],
            ];
        }

        return array_merge($craft31Behaviors, [
            'typecast' => [
                'class' => AttributeTypecastBehavior::class,
                // 'attributeTypes' will be composed automatically according to `rules()`
            ],
        ]);
    }
}

nystudio107 / craft-seomatic

MetaBundle::normalizeMetaBundleData() F last analyzed 2025-10-23 20:51 UTC

Complexity

Size

Duplication

Code Coverage

Importance

How to fix Long Method Complexity

Long Method

Duplication Side-by-Side

Filter issues like

MetaBundle::normalizeMetaBundleData() F
last analyzed 2025-10-23 20:51 UTC
