Taxonomy::__get() - Code Metrics - Inspection of "refactor PostType and Taxonomy with base Type" - aaemnnosttv/silk - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Branch — develop (409c5d)

by Evan

created 2016-07-15 11:01 UTC

Taxonomy::__get() A

↳ Parent: Project

Complexity

Conditions	3
Paths	3

Size

Total Lines	12
Code Lines	6

Duplication

Lines	0
Ratio	0 %

Importance

Changes	2
Bugs	0	Features	2

Metric	Value
c	2
b	0
f	2
dl	0
loc	12
cc	3
eloc	6
nc	3
nop	1
rs	9.4285

<?php

namespace Silk\Taxonomy;

use Silk\Type\Type;
use Silk\PostType\PostType;
use Silk\Taxonomy\Builder;
use Silk\Term\QueryBuilder;
use Illuminate\Support\Collection;
use Silk\Exception\WP_ErrorException;
use Silk\Taxonomy\Exception\InvalidTaxonomyNameException;
use Silk\Taxonomy\Exception\NonExistentTaxonomyException;

/**
 * @property-read bool     $_builtin
 * @property-read stdClass $cap
 * @property-read string   $description
 * @property-read bool     $hierarchical
 * @property-read string   $label
 * @property-read stdClass $labels
 * @property-read callable $meta_box_cb
 * @property-read string   $name
 * @property-read array    $object_type
 * @property-read bool     $public
 * @property-read bool     $publicly_queryable
 * @property-read string   $query_var
 * @property-read array    $rewrite
 * @property-read bool     $show_admin_column
 * @property-read bool     $show_in_menu
 * @property-read bool     $show_in_nav_menus
 * @property-read bool     $show_in_quick_edit
 * @property-read bool     $show_tagcloud
 * @property-read bool     $show_ui
 * @property-read callable $update_count_callback
 */
class Taxonomy extends Type
{
    /**
     * Taxonomy Constructor.
     *
     * @param object $taxonomy The taxonomy object
     *
     * @throws \Silk\Taxonomy\Exception\NonExistentTaxonomyException
     */
    public function __construct($taxonomy)
    {
        if (empty($taxonomy->name) || ! static::exists($taxonomy->name)) {
            throw new NonExistentTaxonomyException;
        }

        $this->object = $taxonomy;
    }

    /**
     * Create a new instance using the taxonomy identifier.
     *
     * @param  string $identifier Taxonomy name/identifier
     *
     * @throws \Silk\Taxonomy\Exception\InvalidTaxonomyNameException
     *
     * @return static
     */
    public static function make($identifier)
    {
        if (static::exists($identifier)) {
            return new static(get_taxonomy($identifier));
        }

        if (! $identifier || strlen($identifier) > 32) {
            throw new InvalidTaxonomyNameException('Taxonomy names must be between 1 and 32 characters in length.');
        }

        return new Builder($identifier);
class Author {
    private $name;

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

    public function getName() {
        return $this->name;
    }
}

abstract class Post {
    public function getAuthor() {
        return 'Johannes';
    }
}

class BlogPost extends Post {
    public function getAuthor() {
        return new Author('Johannes');
    }
}

class ForumPost extends Post { /* ... */ }

function my_function(Post $post) {
    echo strtoupper($post->getAuthor());
}
    }

    /**
     * Check if the given taxonomy exists.
     *
     * @param  string $id The taxonomy key/identifier
     *
     * @return bool
     */
    public static function exists($id)
    {
        return taxonomy_exists($id);
    }

    /**
     * Start a new query for terms of this taxonomy.
     *
     * @return QueryBuilder
     */
    public function terms()
    {
        return (new QueryBuilder)->forTaxonomy($this->id);
    }

    /**
     * Get all post types associated with this taxonomy.
     *
     * @return Collection
     */
    public function postTypes()
    {
        return Collection::make($this->object_type)
            ->map(function ($post_type) {
                return PostType::load($post_type);
            });
    }

    /**
     * Unregister the taxonomy.
     *
     * @throws \Silk\Taxonomy\Exception\NonExistentTaxonomyException
     * @throws \Silk\Exception\WP_ErrorException
     *
     * @return $this
     */
    public function unregister()
    {
        if (! $this->exists($this->id)) {
            throw new NonExistentTaxonomyException;
        }

        if (is_wp_error($error = unregister_taxonomy($this->id))) {
            throw new WP_ErrorException($error);
        }

        return $this;
    }
}


1			<?php
2
3			namespace Silk\Taxonomy;
4
5			use Silk\Type\Type;
6			use Silk\PostType\PostType;
7			use Silk\Taxonomy\Builder;
8			use Silk\Term\QueryBuilder;
9			use Illuminate\Support\Collection;
10			use Silk\Exception\WP_ErrorException;
11			use Silk\Taxonomy\Exception\InvalidTaxonomyNameException;
12			use Silk\Taxonomy\Exception\NonExistentTaxonomyException;
13
14			/**
15			* @property-read bool $_builtin
16			* @property-read stdClass $cap
17			* @property-read string $description
18			* @property-read bool $hierarchical
19			* @property-read string $label
20			* @property-read stdClass $labels
21			* @property-read callable $meta_box_cb
22			* @property-read string $name
23			* @property-read array $object_type
24			* @property-read bool $public
25			* @property-read bool $publicly_queryable
26			* @property-read string $query_var
27			* @property-read array $rewrite
28			* @property-read bool $show_admin_column
29			* @property-read bool $show_in_menu
30			* @property-read bool $show_in_nav_menus
31			* @property-read bool $show_in_quick_edit
32			* @property-read bool $show_tagcloud
33			* @property-read bool $show_ui
34			* @property-read callable $update_count_callback
35			*/
36			class Taxonomy extends Type
37			{
38			/**
39			* Taxonomy Constructor.
40			*
41			* @param object $taxonomy The taxonomy object
42			*
43			* @throws \Silk\Taxonomy\Exception\NonExistentTaxonomyException
44			*/
45			public function __construct($taxonomy)
46			{
47			if (empty($taxonomy->name) \|\| ! static::exists($taxonomy->name)) {
48			throw new NonExistentTaxonomyException;
49			}
50
51			$this->object = $taxonomy;
52			}
53
54			/**
55			* Create a new instance using the taxonomy identifier.
56			*
57			* @param string $identifier Taxonomy name/identifier
58			*
59			* @throws \Silk\Taxonomy\Exception\InvalidTaxonomyNameException
60			*
61			* @return static
62			*/
63			public static function make($identifier)
64			{
65			if (static::exists($identifier)) {
66			return new static(get_taxonomy($identifier));
67			}
68
69			if (! $identifier \|\| strlen($identifier) > 32) {
70			throw new InvalidTaxonomyNameException('Taxonomy names must be between 1 and 32 characters in length.');
71			}
72
73			return new Builder($identifier);
			0 ignored issues – show Bug Best Practice introduced 2016-07-12 14:21 UTC by Report Bug Copy Issue Report The return type of `return new \Silk\Taxonomy\Builder($identifier);` (`Silk\Taxonomy\Builder`) is incompatible with the return type documented by `Silk\Taxonomy\Taxonomy::make` of type `Silk\Taxonomy\Taxonomy`. If you return a value from a function or method, it should be a sub-type of the type that is given by the parent type f.e. an interface, or abstract method. This is more formally defined by the Lizkov substitution principle, and guarantees that classes that depend on the parent type can use any instance of a child type interchangably. This principle also belongs to the SOLID principles for object oriented design. Let’s take a look at an example: class Author { private $name; public function __construct($name) { $this->name = $name; } public function getName() { return $this->name; } } abstract class Post { public function getAuthor() { return 'Johannes'; } } class BlogPost extends Post { public function getAuthor() { return new Author('Johannes'); } } class ForumPost extends Post { /* ... */ } function my_function(Post $post) { echo strtoupper($post->getAuthor()); } Our function `my_function` expects a `Post` object, and outputs the author of the post. The base class `Post` returns a simple string and outputting a simple string will work just fine. However, the child class `BlogPost` which is a sub-type of `Post` instead decided to return an `object`, and is therefore violating the SOLID principles. If a `BlogPost` were passed to `my_function`, PHP would not complain, but ultimately fail when executing the `strtoupper` call in its body. Loading history...
74			}
75
76			/**
77			* Check if the given taxonomy exists.
78			*
79			* @param string $id The taxonomy key/identifier
80			*
81			* @return bool
82			*/
83			public static function exists($id)
84			{
85			return taxonomy_exists($id);
86			}
87
88			/**
89			* Start a new query for terms of this taxonomy.
90			*
91			* @return QueryBuilder
92			*/
93			public function terms()
94			{
95			return (new QueryBuilder)->forTaxonomy($this->id);
96			}
97
98			/**
99			* Get all post types associated with this taxonomy.
100			*
101			* @return Collection
102			*/
103			public function postTypes()
104			{
105			return Collection::make($this->object_type)
106			->map(function ($post_type) {
107			return PostType::load($post_type);
108			});
109			}
110
111			/**
112			* Unregister the taxonomy.
113			*
114			* @throws \Silk\Taxonomy\Exception\NonExistentTaxonomyException
115			* @throws \Silk\Exception\WP_ErrorException
116			*
117			* @return $this
118			*/
119			public function unregister()
120			{
121			if (! $this->exists($this->id)) {
122			throw new NonExistentTaxonomyException;
123			}
124
125			if (is_wp_error($error = unregister_taxonomy($this->id))) {
126			throw new WP_ErrorException($error);
127			}
128
129			return $this;
130			}
131			}
132

aaemnnosttv / silk

Branch — develop (409c5d)

Taxonomy::__get() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like