RoutableTrait::syncObjectRoutes() - Code Metrics - Inspection of "Add a method to sync the object routes with the ob..." - locomotivemtl/charcoal-base - Measure and Improve Code Quality continuously with Scrutinizer

Completed
Push — master ( f4fe64...9bb04b )

unknown
created 2016-10-14 21:21 UTC
RoutableTrait::syncObjectRoutes() B

↳ Parent: RoutableTrait
Complexity

Conditions	4
Paths	3
Size

Total Lines	27
Code Lines	16
Duplication

Lines	0
Ratio	0 %
Importance

Changes
Metric	Value
dl	0
loc	27
rs	8.5806
c	0
b	0
f	0
cc	4
eloc	16
nc	3
nop	0
<?php

namespace Charcoal\Object;

use \InvalidArgumentException;

// From 'charcoal-core'
use \Charcoal\Loader\CollectionLoader;

// From 'charcoal-translation'
use \Charcoal\Translation\TranslationString;
use \Charcoal\Translation\TranslationConfig;

// From 'charcoal-view'
use \Charcoal\View\ViewableInterface;

// Local Dependencies
use \Charcoal\Object\ObjectRoute;
use \Charcoal\Object\ObjectRouteInterface;

/**
 * Full implementation, as Trait, of the `RoutableInterface`.
 */
trait RoutableTrait
{
    /**
     * The object's route.
     *
     * @var TranslationString|string|null
     */
    protected $slug;

    /**
     * Whether the slug is editable.
     *
     * If FALSE, the slug is always auto-generated from its pattern.
     * If TRUE, the slug is auto-generated only if the slug is empty.
     *
     * @var boolean|null
     */
    private $isSlugEditable;

    /**
     * The object's route pattern.
     *
     * @var TranslationString|string|null
     */
    private $slugPattern = '';

    /**
     * A prefix for the object's route.
     *
     * @var TranslationString|string|null
     */
    private $slugPrefix = '';

    /**
     * A suffix for the object's route.
     *
     * @var TranslationString|string|null
     */
    private $slugSuffix = '';

    /**
     * Latest ObjectRoute object concerning the current object.
     *
     * @var ObjectRouteInterface
     */
    private $latestObjectRoute;

    /**
     * The class name of the object route model.
     *
     * Must be a fully-qualified PHP namespace and an implementation of
     * {@see \Charcoal\Object\ObjectRouteInterface}. Used by the model factory.
     *
     * @var string
     */
    private $objectRouteClass = ObjectRoute::class;

    /**
     * Set the object's URL slug pattern.
     *
     * @param mixed $pattern The slug pattern.
     * @return RoutableInterface Chainable
     */
    public function setSlugPattern($pattern)
    {
        if (TranslationString::isTranslatable($pattern)) {
            $this->slugPattern = new TranslationString($pattern);
        } else {
            $this->slugPattern = null;
        }

        return $this;
    }

    /**
     * Retrieve the object's URL slug pattern.
     *
     * @throws InvalidArgumentException If a slug pattern is not defined.
     * @return TranslationString|null
     */
    public function slugPattern()
    {
        if (!$this->slugPattern) {
            $metadata = $this->metadata();
trait Idable {
    public function equalIds(Idable $other) {
        return $this->getId() === $other->getId();
    }
}

            if (isset($metadata['routable']['pattern'])) {
                $this->setSlugPattern($metadata['routable']['pattern']);
            } elseif (isset($metadata['slug_pattern'])) {
                $this->setSlugPattern($metadata['slug_pattern']);
            } else {
                throw new InvalidArgumentException(
                    sprintf('Undefined route pattern (slug) for %s', get_called_class())
                );
            }
        }

        return $this->slugPattern;
    }

    /**
     * Retrieve route prefix for the object's URL slug pattern.
     *
     * @return TranslationString|null
     */
    public function slugPrefix()

    {
        if (!$this->slugPrefix) {
            $metadata = $this->metadata();
trait Idable {
    public function equalIds(Idable $other) {
        return $this->getId() === $other->getId();
    }
}

            if (isset($metadata['routable']['prefix'])) {
                $affix = $metadata['routable']['prefix'];

                if (TranslationString::isTranslatable($affix)) {
                    $this->slugPrefix = new TranslationString($affix);
                }
            }
        }

        return $this->slugPrefix;
    }

    /**
     * Retrieve route suffix for the object's URL slug pattern.
     *
     * @return TranslationString|null
     */
    public function slugSuffix()

    {
        if (!$this->slugSuffix) {
            $metadata = $this->metadata();
trait Idable {
    public function equalIds(Idable $other) {
        return $this->getId() === $other->getId();
    }
}

            if (isset($metadata['routable']['suffix'])) {
                $affix = $metadata['routable']['suffix'];

                if (TranslationString::isTranslatable($affix)) {
                    $this->slugSuffix = new TranslationString($affix);
                }
            }
        }

        return $this->slugSuffix;
    }

    /**
     * Determine if the slug is editable.
     *
     * @return boolean
     */
    public function isSlugEditable()
    {
        if ($this->isSlugEditable === null) {
            $metadata = $this->metadata();
trait Idable {
    public function equalIds(Idable $other) {
        return $this->getId() === $other->getId();
    }
}

            if (isset($metadata['routable']['editable'])) {
                $this->isSlugEditable = !!$metadata['routable']['editable'];
            } else {
                $this->isSlugEditable = false;
            }
        }

        return $this->isSlugEditable;
    }

    /**
     * Set the object's URL slug.
     *
     * @param mixed $slug The slug.
     * @return RoutableInterface Chainable
     */
    public function setSlug($slug)
// Bad
class Router
{
    public function generate($path)
    {
        return $_SERVER['HOST'].$path;
    }
}

// Better
class Router
{
    private $host;

    public function __construct($host)
    {
        $this->host = $host;
    }

    public function generate($path)
    {
        return $this->host.$path;
    }
}

class Controller
{
    public function myAction(Request $request)
    {
        // Instead of
        $page = isset($_GET['page']) ? intval($_GET['page']) : 1;

        // Better (assuming you use the Symfony2 request)
        $page = $request->query->get('page', 1);
    }
}
    {
        if (TranslationString::isTranslatable($slug)) {
            $this->slug = new TranslationString($slug);

            $values = $this->slug->all();
            foreach ($values as $lang => $val) {
                $this->slug[$lang] = $this->slugify($val);
            }
        } else {
            /** @todo Hack used for regenerating route */
            if (isset($_POST['slug'])) {
                $this->slug = [];

            } else {
                $this->slug = null;
            }
        }

        return $this;
    }

    /**
     * Retrieve the object's URL slug.
     *
     * @return TranslationString|null
     */
    public function slug()
    {
        return $this->slug;
    }

    /**
     * Generate a URL slug from the object's URL slug pattern.
     *
     * @return TranslationString
     */
    public function generateSlug()
    {
        $translator = TranslationConfig::instance();
        $patterns   = $this->slugPattern();
        $curSlug    = $this->slug();
        $newSlug    = new TranslationString();

        if ($patterns instanceof TranslationString) {
            $patterns = $patterns->all();
        }

        $origLang = $translator->currentLanguage();
        foreach ($patterns as $lang => $pattern) {
$collection = json_decode($data, true);
if ( ! is_array($collection)) {
    throw new \RuntimeException('$collection must be an array.');
}

foreach ($collection as $item) { /** ... */ }
            if (!$translator->hasLanguage($lang)) {
                continue;
            }

            $translator->setCurrentLanguage($lang);
            if ($this->isSlugEditable() && isset($curSlug[$lang]) && strlen($curSlug[$lang])) {
                $newSlug[$lang] = $curSlug[$lang];
            } else {
                $newSlug[$lang] = $this->generateRoutePattern($pattern);
                if (!strlen($newSlug[$lang])) {
                    throw new \UnexpectedValueException(
                        sprintf('The slug is empty. The pattern is "%s"', $pattern)
                    );
                }
            }
            $newSlug[$lang] = $this->finalizeSlug($newSlug[$lang]);

            $objectRoute = $this->createRouteObject();
            if ($objectRoute->source()->tableExists()) {
                $objectRoute->setData([
                    'lang'           => $lang,
                    'slug'           => $newSlug[$lang],
                    'route_obj_type' => $this->objType(),
trait Idable {
    public function equalIds(Idable $other) {
        return $this->getId() === $other->getId();
    }
}
                    'route_obj_id'   => $this->id()
trait Idable {
    public function equalIds(Idable $other) {
        return $this->getId() === $other->getId();
    }
}
                ]);

                if (!$objectRoute->isSlugUnique()) {
                    $objectRoute->generateUniqueSlug();
                    $newSlug[$lang] = $objectRoute->slug();
                }
            }
        }
        $translator->setCurrentLanguage($origLang);

        return $newSlug;
    }

    /**
     * Generate a route from the given pattern.
     *
     * @uses   self::parseRouteToken() If a view renderer is unavailable.
     * @param  string $pattern The slug pattern.
     * @return string Returns the generated route.
     */
    protected function generateRoutePattern($pattern)
    {
        if ($this instanceof ViewableInterface && $this->view() !== null) {
            $route = $this->view()->render($pattern, $this->viewController());
        } else {
            $route = preg_replace_callback('~\{\{\s*(.*?)\s*\}\}~i', [$this, 'parseRouteToken'], $pattern);
        }

        return $this->slugify($route);
    }

    /**
     * Parse the given slug (URI token) for the current object.
     *
     * @used-by self::generateRoutePattern() If a view renderer is unavailable.
     * @uses    self::filterRouteToken() For customize the route value filtering,
     * @param   string|array $token The token to parse relative to the model entry.
     * @throws  InvalidArgumentException If a route token is not a string.
     * @return  string
     */
    protected function parseRouteToken($token)
    {
        // Processes matches from a regular expression operation
        if (is_array($token) && isset($token[1])) {
            $token = $token[1];
        }

        $token  = trim($token);
        $method = [$this, $token];

        if (is_callable($method)) {
            $value = call_user_func($method);
            /** @see \Charcoal\Config\AbstractEntity::offsetGet() */
        } elseif (isset($this[$token])) {
            $value = $this[$token];
        } else {
            return '';
        }

        $value = $this->filterRouteToken($value, $token);
        if (!is_string($value) && !is_numeric($value)) {
            throw new InvalidArgumentException(
                sprintf(
                    'Route token "%1$s" must be a string with %2$s',
                    $token,
                    get_called_class()
                )
            );
        }

        return $value;
    }

    /**
     * Filter the given value for a URI.
     *
     * @used-by self::parseRouteToken() To resolve the token's value.
     * @param   mixed  $value A value to filter.
     * @param   string $token The parsed token.
     * @return  string The filtered $value.
     */
    protected function filterRouteToken($value, $token = null)
    {
        unset($token);

        if ($value instanceof \Closure) {
            $value = $value();
        }

        if ($value instanceof \DateTime) {
            $value = $value->format('Y-m-d-H:i');
        }

        return $value;
    }

    /**
     * Route generation.
     *
     * Saves all routes to {@see \Charcoal\Object\ObjectRoute}.
     *
     * @param  mixed $slug Slug by langs.
     * @return void
     */
    protected function generateObjectRoute($slug = null)
    {
        $translator = TranslationConfig::instance();

        if (!$slug) {
            $slug = $this->generateSlug();
        }

        if ($slug instanceof TranslationString) {
            $slugs = $slug->all();
        }

        $origLang = $translator->currentLanguage();
        foreach ($slugs as $lang => $slug) {
function myFunction($a) {
    switch ($a) {
        case 'foo':
            $x = 1;
            break;

        case 'bar':
            $x = 2;
            break;
    }

    // $x is potentially undefined here.
    echo $x;
}
            if (!$translator->hasLanguage($lang)) {
                continue;
            }

            $translator->setCurrentLanguage($lang);

            $objectRoute = $this->createRouteObject();

            $source = $objectRoute->source();
            if (!$source->tableExists()) {
                $source->createTable();
            } else {
                $oldRoute = $this->getLatestObjectRoute();

                // Unchanged
                if ($slug === $oldRoute->slug()) {
                    continue;
                }
            }

            $objectRoute->setData([
                'lang'           => $lang,
                'slug'           => $slug,
                'route_obj_type' => $this->objType(),
trait Idable {
    public function equalIds(Idable $other) {
        return $this->getId() === $other->getId();
    }
}
                'route_obj_id'   => $this->id(),
trait Idable {
    public function equalIds(Idable $other) {
        return $this->getId() === $other->getId();
    }
}
                // Not used, might be too much.
                'route_template' => $this->templateIdent(),
                'active'         => true
            ]);

            if (!$objectRoute->isSlugUnique()) {
                $objectRoute->generateUniqueSlug();
            }

            if ($objectRoute->id()) {
                $objectRoute->update();
            } else {
                $objectRoute->save();
            }
        }
        $translator->setCurrentLanguage($origLang);
    }

    /**
     * Retrieve the latest object route.
     *
     * @param  string|null $lang If object is multilingual, return the object route for the specified locale.
     * @throws InvalidArgumentException If the given language is invalid.
     * @return ObjectRouteInterface Latest object route.
     */
    protected function getLatestObjectRoute($lang = null)
    {
        $translator = TranslationConfig::instance();

        if ($lang === null) {
            $lang = $translator->currentLanguage();
        } elseif (!$translator->hasLanguage($lang)) {
            throw new InvalidArgumentException(
                sprintf(
                    'Invalid language, received %s',
                    (is_object($lang) ? get_class($lang) : gettype($lang))
                )
            );
        }

        if (isset($this->latestObjectRoute[$lang])) {
            return $this->latestObjectRoute[$lang];
        }

        $model = $this->createRouteObject();

        if (!$this->objType() || !$this->id()) {
trait Idable {
    public function equalIds(Idable $other) {
        return $this->getId() === $other->getId();
    }
}
            $this->latestObjectRoute[$lang] = $model;

            return $this->latestObjectRoute[$lang];
        }

        // For URL.
        $source = $model->source();
        $loader = new CollectionLoader([
            'logger'  => $this->logger,
class MyClass { }

$x = new MyClass();
$x->foo = true;
            'factory' => $this->modelFactory()
        ]);

        if (!$source->tableExists()) {
            $source->createTable();
        }

        $loader
            ->setModel($model)
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
            ->addFilter('route_obj_type', $this->objType())
trait Idable {
    public function equalIds(Idable $other) {
        return $this->getId() === $other->getId();
    }
}
            ->addFilter('route_obj_id', $this->id())
trait Idable {
    public function equalIds(Idable $other) {
        return $this->getId() === $other->getId();
    }
}
            ->addFilter('lang', $lang)
            ->addFilter('active', true)
            ->addOrder('creation_date', 'desc')
            ->setPage(1)
            ->setNumPerPage(1);

        $collection = $loader->load()->objects();

        if (!count($collection)) {
            $this->latestObjectRoute[$lang] = $model;

            return $this->latestObjectRoute[$lang];
        }

        $this->latestObjectRoute[$lang] = $collection[0];

        return $this->latestObjectRoute[$lang];
    }

    /**
     * Sync the object routes with the object's data.
     * @return void
     */
    public function syncObjectRoutes()
    {
        $model = $this->createRouteObject();

        if (!$this->objType() || !$this->id()) {
trait Idable {
    public function equalIds(Idable $other) {
        return $this->getId() === $other->getId();
    }
}
            return;
        }

        $loader = new CollectionLoader([
            'logger'  => $this->logger,
            'factory' => $this->modelFactory()
        ]);

        $loader
            ->setModel($model)
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
            ->addFilter('route_obj_type', $this->objType())
trait Idable {
    public function equalIds(Idable $other) {
        return $this->getId() === $other->getId();
    }
}
            ->addFilter('route_obj_id', $this->id());
trait Idable {
    public function equalIds(Idable $other) {
        return $this->getId() === $other->getId();
    }
}

        $collection = $loader->load();

        foreach ($collection as $entry) {
            $entry->setData([
                'route_template' => $this->templateIdent()
            ]);
            $entry->update();
        }
    }

    /**
     * Retrieve the object's URI.
     *
     * @param  string|null $lang If object is multilingual, return the object route for the specified locale.
     * @return TranslationString|string
     */
    public function url($lang = null)
    {
        $url = (string)$this->getLatestObjectRoute($lang)->slug();
        if ($url) {
            return $url;
        }

        $slug = $this->slug();

        if ($slug instanceof TranslationString && $lang) {
''   == false // true
''   == null  // true
'ab' == false // false
'ab' == null  // false

// It is often better to use strict comparison
'' === false // false
'' === null  // false
            return $slug->val($lang);
        }

        return (string)$slug;
    }

    /**
     * Convert a string into a slug.
     *
     * @param  string $str The string to slugify.
     * @return string The slugified string.
     */
    public function slugify($str)
    {
        static $sluggedArray;

        if (isset($sluggedArray[$str])) {
            return $sluggedArray[$str];
        }

        $metadata    = $this->metadata();
trait Idable {
    public function equalIds(Idable $other) {
        return $this->getId() === $other->getId();
    }
}
        $separator   = isset($metadata['routable']['separator']) ? $metadata['routable']['separator'] : '-';
        $delimiters  = '-_|';
        $pregDelim   = preg_quote($delimiters);
        $directories = '\\/';
        $pregDir     = preg_quote($directories);

        // Do NOT remove forward slashes.
        $slug = preg_replace('![^(\p{L}|\p{N})(\s|\/)]!u', $separator, $str);

        if (!isset($metadata['routable']['lowercase']) || $metadata['routable']['lowercase'] === false) {
            $slug = mb_strtolower($slug, 'UTF-8');
        }

        // Strip HTML
        $slug = strip_tags($slug);

        // Remove diacritics
        $slug = preg_replace(
            '!&([a-zA-Z])(uml|acute|grave|circ|tilde|cedil|ring);!',
            '$1',
            htmlentities($slug, ENT_COMPAT, 'UTF-8')
        );

        // Remove unescaped HTML characters
        $unescaped = '!&(raquo|laquo|rsaquo|lsaquo|rdquo|ldquo|rsquo|lsquo|hellip|amp|nbsp|quot|ordf|ordm);!';
        $slug      = preg_replace($unescaped, '', $slug);

        // Unify all dashes/underscores as one separator character
        $flip = ($separator === '-') ? '_' : '-';
        $slug = preg_replace('!['.preg_quote($flip).']+!u', $separator, $slug);

        // Remove all whitespace and normalize delimiters
        $slug = preg_replace('![_\|\s]+!', $separator, $slug);

        // Squeeze multiple delimiters and whitespace with a single separator
        $slug = preg_replace('!['.$pregDelim.'\s]{2,}!', $separator, $slug);

        // Squeeze multiple URI path delimiters
        $slug = preg_replace('!['.$pregDir.']{2,}!', $separator, $slug);

        // Remove delimiters surrouding URI path delimiters
        $slug = preg_replace('!(?<=['.$pregDir.'])['.$pregDelim.']|['.$pregDelim.'](?=['.$pregDir.'])!', '', $slug);

        // Strip leading and trailing dashes or underscores
        $slug = trim($slug, $delimiters);

        // Cache the slugified string
        $sluggedArray[$str] = $slug;

        return $slug;
    }

    /**
     * Finalize slug.
     *
     * Adds any prefix and suffix defined in the routable configuration set.
     *
     * @param  string $slug A slug.
     * @return string
     */
    protected function finalizeSlug($slug)
    {
        $prefix = $this->slugPrefix();
        if ($prefix) {

            $prefix = $this->generateRoutePattern((string)$prefix);
            if ($slug === $prefix) {
                throw new \UnexpectedValueException('The slug is the same as the prefix.');
            }
            $slug = $prefix.preg_replace('!^'.preg_quote($prefix).'\b!', '', $slug);
        }

        $suffix = $this->slugSuffix();
        if ($suffix) {

            $suffix = $this->generateRoutePattern((string)$suffix);
            if ($slug === $suffix) {
                throw new \UnexpectedValueException('The slug is the same as the suffix.');
            }
            $slug = preg_replace('!\b'.preg_quote($suffix).'$!', '', $slug).$suffix;
        }

        return $slug;
    }

    /**
     * Delete all object routes.
     *
     * Should be called on object deletion {@see \Charcoal\Model\AbstractModel::preDelete()}.
     *
     * @return boolean Success or failure.
     */
    protected function deleteObjectRoutes()
    {
        if (!$this->objType()) {
trait Idable {
    public function equalIds(Idable $other) {
        return $this->getId() === $other->getId();
    }
}
            return false;
        }

        if (!$this->id()) {
trait Idable {
    public function equalIds(Idable $other) {
        return $this->getId() === $other->getId();
    }
}
            return false;
        }

        $model  = $this->modelFactory()->get($this->objectRouteClass());
        $loader = new CollectionLoader([
            'logger'  => $this->logger,
            'factory' => $this->modelFactory()
        ]);

        $loader
            ->setModel($model)
            ->addFilter('route_obj_type', $this->objType())
trait Idable {
    public function equalIds(Idable $other) {
        return $this->getId() === $other->getId();
    }
}
            ->addFilter('route_obj_id', $this->id());
trait Idable {
    public function equalIds(Idable $other) {
        return $this->getId() === $other->getId();
    }
}

        $collection = $loader->load();
        foreach ($collection as $route) {
            $route->delete();
        }

        return true;
    }

    /**
     * Create a route object.
     *
     * @return ObjectRouteInterface
     */
    public function createRouteObject()
    {
        $route = $this->modelFactory()->create($this->objectRouteClass());

        return $route;
    }

    /**
     * Set the class name of the object route model.
     *
     * @param  string $className The class name of the object route model.
     * @throws InvalidArgumentException If the class name is not a string.
     * @return AbstractPropertyDisplay Chainable
     */
    protected function setObjectRouteClass($className)
    {
        if (!is_string($className)) {
            throw new InvalidArgumentException(
                'Route class name must be a string.'
            );
        }

        $this->objectRouteClass = $className;

        return $this;
    }

    /**
     * Retrieve the class name of the object route model.
     *
     * @return string
     */
    public function objectRouteClass()
    {
        return $this->objectRouteClass;
    }

    /**
     * Retrieve the object model factory.
     *
     * @return \Charcoal\Factory\FactoryInterface
     */
    abstract public function modelFactory();

    /**
     * Retrieve the routable object's template identifier.
     *
     * @return mixed
     */
    abstract public function templateIdent();
}

1			<?php
2
3			namespace Charcoal\Object;
4
5			use \InvalidArgumentException;
6
7			// From 'charcoal-core'
8			use \Charcoal\Loader\CollectionLoader;
9
10			// From 'charcoal-translation'
11			use \Charcoal\Translation\TranslationString;
12			use \Charcoal\Translation\TranslationConfig;
13
14			// From 'charcoal-view'
15			use \Charcoal\View\ViewableInterface;
16
17			// Local Dependencies
18			use \Charcoal\Object\ObjectRoute;
19			use \Charcoal\Object\ObjectRouteInterface;
20
21			/**
22			* Full implementation, as Trait, of the `RoutableInterface`.
23			*/
24			trait RoutableTrait
25			{
26			/**
27			* The object's route.
28			*
29			* @var TranslationString\|string\|null
30			*/
31			protected $slug;
32
33			/**
34			* Whether the slug is editable.
35			*
36			* If FALSE, the slug is always auto-generated from its pattern.
37			* If TRUE, the slug is auto-generated only if the slug is empty.
38			*
39			* @var boolean\|null
40			*/
locomotivemtl / charcoal-base

Push — master ( f4fe64...9bb04b )

RoutableTrait::syncObjectRoutes() B

Complexity

Size

Duplication

Importance

Available Fixes

Duplication Side-by-Side

Filter issues like
