Silk\Post\PostType

Complexity

Total Complexity

20

Size/Duplication

Total Lines	160
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	4

Importance

Changes	2
Bugs	0	Features	0

10 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
A	make()	0	8	2
A	load()	0	8	2
A	exists()	0	4	1
A	object()	0	4	1
A	supports()	0	11	2
A	addSupportFor()	0	6	2
A	removeSupportFor()	0	9	2
A	unregister()	0	14	3
A	__get()	0	10	4

<?php

namespace Silk\Post;

use stdClass;
use InvalidArgumentException;
use Illuminate\Support\Collection;
use Silk\Exception\WP_ErrorException;
use Silk\Post\Exception\InvalidPostTypeNameException;
use Silk\Post\Exception\NonExistentPostTypeException;
use Silk\Post\PostTypeBuilder;

/**
 * @property-read string $slug
 * @property-read string $one
 * @property-read string $many
 */
class PostType
{
    /**
     * Post type object
     * @var stdClass
     */
    protected $object;

    /**
     * PostType Constructor
     *
     * @param object post type object
     */
    public function __construct(stdClass $object)
    {
        $this->object = $object;
    }

    /**
     * Create a new instance using the post type slug.
     *
     * Loads an existing type, or returns a new builder for registering a new type.
     *
     * @param  string $slug  string - the post type slug ("name")
     *
     * @return mixed         static - if the post type has been registered
     *                       PostTypeBuilder otherwise
     */
    public static function make($slug)
    {
        if (static::exists($slug)) {
            return static::load($slug);
        }

        return new PostTypeBuilder($slug);
    }

    /**
     * Create a new instance from an existing type.
     *
     * @param  string $slug  post type id  (slug/name)
     *
     * @return static
     */
    public static function load($slug)
    {
        if (! $object = get_post_type_object($slug)) {
            throw new NonExistentPostTypeException("No post type exists with name '$slug'.");
        }

        return new static($object);
    }

    /**
     * Checks if a post type with this slug has been registered.
     *
     * @return bool
     */
    public static function exists($slug)
    {
        return post_type_exists($slug);
    }

    /**
     * Get the post type object.
     *
     * @return object
     */
    public function object()
    {
        return $this->object;
    }

    /**
     * Check for feature support.
     *
     * @param mixed $features  string - feature
     *                         array - many features
     *
     * @return mixed
     */
    public function supports($features)
    {
        if (! is_array($features)) {
            $features = func_get_args();
        }

        return ! collect($features)
            ->contains(function ($key, $feature) {
                return ! post_type_supports($this->slug, $feature);
            });
    }

    /**
     * Register support of certain features for an existing post type.
     *
     * @param mixed $features  string - single feature to add
     *                        array - multiple features to add
     */
    public function addSupportFor($features)
    {
        add_post_type_support($this->slug, is_array($features) ? $features : func_get_args());

        return $this;
    }

    /**
     * Deregister support of certain features for an existing post type.
     *
     * @param mixed $features  string - single feature to remove
     *                        array - multiple features to remove
     */
    public function removeSupportFor($features)
    {
        collect(is_array($features) ? $features : func_get_args())
            ->each(function ($features) {
                remove_post_type_support($this->slug, $features);
            });

        return $this;
    }

    /**
     * Unregister the post type
     *
     * @return $this
     */
    public function unregister()
    {
        if (! static::exists($this->slug)) {
            throw new NonExistentPostTypeException("No post type exists with name '{$this->slug}'.");
        }

        $result = unregister_post_type($this->slug);

        if (is_wp_error($result)) {
            throw new WP_ErrorException($result);
        }

        return $this;
    }

    /**
     * Magic Getter
     *
     * @param  string $property
     *
     * @return mixed
     */
    public function __get($property)
    {
        switch ($property) :
            case 'slug': return $this->object->name;

The case body in a switch statement must start on the line following the statement.

Terminating statement must be on a line by itself

            case 'one':  return $this->object->labels->singular_name;

The case body in a switch statement must start on the line following the statement.

Terminating statement must be on a line by itself

            case 'many': return $this->object->labels->name;

The case body in a switch statement must start on the line following the statement.

Terminating statement must be on a line by itself

        endswitch;

        return null;
    }
}