ViewableDataObject::validURLSegment() - Code Metrics - Inspection of "Merge pull request #16 from jsirish/bugfix/ss4stab..." - dynamic/viewable-dataobject - Measure and Improve Code Quality continuously with Scrutinizer

Completed
Push — master ( 4c93a4...288b18 )

by Jason
created 2017-12-01 05:30 UTC
ViewableDataObject::validURLSegment() C

↳ Parent: ViewableDataObject
Complexity

Conditions	14
Paths	76
Size

Total Lines	40
Code Lines	21
Duplication

Lines	0
Ratio	0 %
Code Coverage

Tests	16
CRAP Score	19.5228
Importance

Changes
Metric	Value
cc	14
eloc	21
c	0
b	0
f	0
nc	76
nop	0
dl	0
loc	40
rs	5.0864
ccs	16
cts	23
cp	0.6957
crap	19.5228
How to fix Complexity

<?php

namespace Dynamic\ViewableDataObject\Extensions;

use SilverStripe\CMS\Controllers\RootURLController;
use SilverStripe\CMS\Model\SiteTree;
use SilverStripe\Control\ContentNegotiator;
use SilverStripe\Control\RequestHandler;
use SilverStripe\ORM\DataExtension;
use SilverStripe\Forms\FieldList;
use SilverStripe\Forms\TextField;
use SilverStripe\Forms\TextareaField;
use SilverStripe\Forms\ToggleCompositeField;
use SilverStripe\CMS\Forms\SiteTreeURLSegmentField;
use SilverStripe\Control\Controller;
use SilverStripe\Control\Director;
use SilverStripe\ORM\FieldType\DBHTMLText;
use SilverStripe\SiteConfig\SiteConfig;
use SilverStripe\CMS\Controllers\ModelAsController;
use SilverStripe\ORM\DataObject;
use SilverStripe\View\HTML;
use SilverStripe\View\Parsers\URLSegmentFilter;
use SilverStripe\Versioned\Versioned;
use SilverStripe\View\SSViewer;
use SilverStripe\ORM\ArrayList;
use SilverStripe\View\ArrayData;
use SilverStripe\Core\Convert;
use SilverStripe\Core\Config\Config;

class ViewableDataObject extends DataExtension
{
    /**
     * @var array
     */
    private static $db = [

        'Title' => 'Varchar(255)',
        'MenuTitle' => 'Varchar(255)',
        'URLSegment' => 'Varchar(255)',
        'MetaTitle' => 'Varchar(255)',
        'MetaDescription' => 'Varchar(255)',
    ];

    /**
     * @var array
     */
    private static $defaults = array(

        'Title' => 'New Item',
        'URLSegment' => 'new-item',
    );

    /**
     * @var array
     */
    private static $indexes = [

        'URLSegment' => true,
    ];

    /**
     * @var array
     */
    private static $casting = array(

        'Breadcrumbs' => 'HTMLFragment',
        'Link' => 'Text',
        'RelativeLink' => 'Text',
        'AbsoluteLink' => 'Text',
        'MetaTags' => 'HTMLFragment',
    );

    /**
     * @param FieldList $fields
     */
    public function updateCMSFields(FieldList $fields)
    {
        $fields->removeByName(array(
            'MenuTitle',
            'URLSegment',
            'MetaTitle',
            'MetaDescription',
        ));

        $fields->insertAfter(
            TextField::create('MenuTitle'),
            TextField::create(/** @scrutinizer ignore-type */ 'MenuTitle'),
            'Title'
            /** @scrutinizer ignore-type */ 'Title'
        );

        if ($page = $this->hasParentPage()) {
            $fields->insertAfter(
                SiteTreeURLSegmentField::create('URLSegment')
                    ->setURLPrefix($page->Link().$this->hasViewAction().'/'),
                'MenuTitle'
            );
        }

        $fields->addFieldToTab(
            'Root.Main',
            ToggleCompositeField::create(
                'Metadata',
                'Metadata',
                array(
                    new TextField('MetaTitle', $this->owner->fieldLabel('MetaTitle')),
                    new TextareaField('MetaDescription', $this->owner->fieldLabel('MetaDescription')),
                )
            )
        );
    }

    /**
     * @return bool
     */
    public function hasParentPage()
    {
        if ($this->owner->hasMethod('getParentPage')) {
            return $this->owner->getParentPage();
        }

        return false;
    }

    /**
     * @return string
     */
    public function hasViewAction()
    {
        if ($this->owner->hasMethod('getViewAction')) {
            return $this->owner->getViewAction();
        }

        return 'view';
    }

    /**
     * @param null $action

     *
     * @return bool|string
     */
    public function Link($action = null)
    {
        if ($this->hasParentPage()) {
            return Controller::join_links(
                $this->hasParentPage()->Link(),
                $this->hasViewAction(),
                $this->owner->RelativeLink($action)
            );
        }

        return false;
    }

    /**
     * @param null $action

     *
     * @return string
     */
    public function AbsoluteLink($action = null)
    {
        if ($this->owner->hasMethod('alternateAbsoluteLink')) {
            return $this->owner->alternateAbsoluteLink($action);
        } else {
            return Director::absoluteURL($this->owner->Link($action));
        }
    }

    /**
     * @param null $action

     *
     * @return string
     */
    public function RelativeLink($action = null)
    {
        if ($this->owner->ParentID && SiteConfig::current_site_config()->nested_urls) {
            $parent = $this->owner->Parent();
            // If page is removed select parent from version history (for archive page view)
            if ((!$parent || !$parent->exists()) && !$this->owner->isOnDraft()) {
                $parent = Versioned::get_latest_version($this->owner->ClassName, $this->owner->ParentID);
            }
            $base = $parent->RelativeLink($this->owner->URLSegment);
        } elseif (!$action && $this->owner->URLSegment == RootURLController::get_homepage_link()) {
            // Unset base for root-level homepages.
            // Note: Homepages with action parameters (or $action === true)
            // need to retain their URLSegment.
            $base = null;
        } else {
            $base = $this->owner->URLSegment;
        }

        $this->owner->extend('updateRelativeLink', $base, $action);

        // Legacy support: If $action === true, retain URLSegment for homepages,
        // but don't append any action
        if ($action === true) {
            $action = null;
        }

        return Controller::join_links($base, '/', $action);
    }

    /**
     * @return bool|mixed
     */
    public function validURLSegment()
    {
        if (SiteConfig::current_site_config()->nested_urls && $parent = $this->owner->Parent()) {
            if ($controller = ModelAsController::controller_for($parent)) {
                if ($controller instanceof Controller && $controller->hasAction($this->owner->URLSegment)) {
                    return false;
                }
            }
        }

        if (!SiteConfig::current_site_config()->nested_urls || !$this->owner->ParentID) {
            if (class_exists($this->owner->URLSegment) &&
                is_subclass_of($this->owner->URLSegment, RequestHandler::class)) {
                return false;
            }
        }

        // Filters by url, id, and parent
        $table = DataObject::getSchema()->tableForField($this->owner->ClassName, 'URLSegment');
        $filter = array('"'.$table.'"."URLSegment"' => $this->owner->URLSegment);
        if ($this->owner->ID) {
            $filter['"'.$table.'"."ID" <> ?'] = $this->owner->ID;
        }
        if (SiteConfig::current_site_config()->nested_urls) {
            $filter['"'.$table.'"."ParentID"'] = $this->owner->ParentID ? $this->owner->ParentID : 0;
        }

        // If any of the extensions return `0` consider the segment invalid
        $extensionResponses = array_filter(
            (array) $this->owner->extend('augmentValidURLSegment'),
            function ($response) {
                return !is_null($response);
            }
        );
        if ($extensionResponses) {

            return min($extensionResponses);
        }

        // Check existence
        return !DataObject::get($this->owner->ClassName, $filter)->exists();
    }

    /**
     * @param $title
     *
     * @return string
     */
    public function generateURLSegment($title)
    {
        $filter = URLSegmentFilter::create();
        $t = $filter->filter($title);
        // Fallback to generic page name if path is empty (= no valid, convertable characters)
        if (!$t || $t == '-' || $t == '-1') {
            $t = "page-$this->owner->ID";
        }
        // Hook for extensions
        $this->owner->extend('updateURLSegment', $t, $title);

        return $t;
    }

    /**
     * Generate custom meta tags to display on the DataObject view page.
     *
     * @param bool $includeTitle
     *
     * @return string
     */
    public function MetaTags($includeTitle = true)
    {
        $tags = '';

        if ($includeTitle === true || $includeTitle == 'true') {
            $tags .= '<title>'.Convert::raw2xml(($this->owner->MetaTitle)
            $tags .= '<title>'./** @scrutinizer ignore-type */ Convert::raw2xml(($this->owner->MetaTitle)
                    ? $this->owner->MetaTitle
                    : $this->owner->Title)
                    ."</title>\n";
        }
        $tags .= "<meta name=\"generator\" content=\"SilverStripe - http://silverstripe.org\" />\n";
        $charset = Config::inst()->get('ContentNegotiator', 'encoding');
        $tags .= "<meta http-equiv=\"Content-type\" content=\"text/html; charset=$charset\" />\n";
        if ($this->owner->MetaDescription) {
            $tags .= '<meta name="description" content="'.Convert::raw2att($this->owner->MetaDescription)."\" />\n";
            $tags .= '<meta name="description" content="'./** @scrutinizer ignore-type */ Convert::raw2att($this->owner->MetaDescription)."\" />\n";
        }
        $this->owner->extend('updateMetaTags', $tags);

        return $tags;
    }

    /**
     * Produce the correct breadcrumb trail for use on the DataObject Item Page.
     *
     * @param int  $maxDepth
     * @param bool $unlinked
     * @param bool $stopAtPageType
     * @param bool $showHidden
     *
     * @return DBHTMLText
     */
    public function Breadcrumbs($maxDepth = 20, $unlinked = false, $stopAtPageType = false, $showHidden = false)
    public function Breadcrumbs($maxDepth = 20, /** @scrutinizer ignore-unused */ $unlinked = false, $stopAtPageType = false, $showHidden = false)
    {
        $page = Controller::curr();
        $pages = array();
        $pages[] = $this->owner;
        while ($page
            && (!$maxDepth || count($pages) < $maxDepth)
            && (!$stopAtPageType || $page->ClassName != $stopAtPageType)
        ) {
            if ($showHidden || $page->ShowInMenus || ($page->ID == $this->owner->ID)) {
                $pages[] = $page;
            }
            $page = $page->Parent;
        }
        $template = new SSViewer('BreadcrumbsTemplate');

        return $template->process($this->owner->customise(new ArrayData(array(
            'Pages' => new ArrayList(array_reverse($pages)),
        ))));
    }

    /**
     *
     */
    public function onBeforeWrite()
    {
        if (!$this->owner->URLSegment) {
            $siteTree = singleton(SiteTree::class);
            $this->owner->URLSegment = $siteTree->generateURLSegment($this->owner->Title);
        }

        // Ensure that this object has a non-conflicting URLSegment value.
        $count = 2;
        while (!$this->owner->validURLSegment()) {
            $this->owner->URLSegment = preg_replace('/-[0-9]+$/', null, $this->owner->URLSegment).'-'.$count;
            ++$count;
        }

        parent::onBeforeWrite();
    }
}

dynamic / viewable-dataobject

Push — master ( 4c93a4...288b18 )

ViewableDataObject::validURLSegment() C

Complexity

Size

Duplication

Code Coverage

Importance

How to fix Complexity

Long Method

Duplication Side-by-Side

Filter issues like
