GeminiLabs\Pollux\MetaBox

Complexity

Total Complexity

44

Size/Duplication

Total Lines	346
Duplicated Lines	4.34 %

Coupling/Cohesion

Components	1
Dependencies	2

Importance

Changes

0

27 Methods

Rating	Name	Duplication	Size	Complexity
A	init()	0	7	1
A	isVisible()	0	9	4
A	register()	0	10	3
A	verifyMetaBoxCondition()	0	10	2
A	addInstructions()	0	18	2
A	generateInstructions()	0	13	1
A	getInstructions()	0	7	2
A	getPostId()	0	7	2
A	getPostTypes()	0	9	1
A	hasPostType()	0	7	2
A	normalize()	15	15	2
A	normalizeCondition()	0	17	4
A	normalizeDepends()	0	6	3
A	normalizeFields()	0	14	1
A	normalizeId()	0	4	1
A	normalizePostTypes()	0	4	1
A	setDependencies()	0	10	2
A	validateClassExists()	0	4	1
A	validateDefined()	0	4	1
A	validateFunctionExists()	0	4	1
A	validateHook()	0	4	1
A	validateIsFrontPage()	0	4	1
A	validateIsHome()	0	4	1
A	validateIsPageTemplate()	0	4	1
A	validateIsPluginActive()	0	4	1
A	validateIsPluginInactive()	0	4	1
A	validateUnknown()	0	4	1

<?php

namespace GeminiLabs\Pollux;

use GeminiLabs\Pollux\Application;
use GeminiLabs\Pollux\Component;
use RecursiveArrayIterator;
use RecursiveIteratorIterator;

class MetaBox extends Component
{
	const CONDITIONS = [
		'class_exists', 'defined', 'function_exists', 'hook', 'is_front_page', 'is_home',
		'is_page_template', 'is_plugin_active', 'is_plugin_inactive',
	];

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

	/**
	 * {@inheritdoc}
	 */
	public function init()
	{
		$this->normalize();

		add_filter( 'rwmb_show',       [$this, 'isVisible'], 10, 2 );
		add_filter( 'rwmb_meta_boxes', [$this, 'register'] );
	}

	/**
	 * @return bool
	 * @filter rwmb_show
	 */
	public function isVisible( $bool, array $metabox )
	{
		if( defined( 'DOING_AJAX' )
			|| !isset( $metabox['condition'] )
			|| !$this->hasPostType( $metabox )) {
			return $bool;
		}
		return $this->verifyMetaBoxCondition( $metabox['condition'] );
	}

	/**
	 * @return array
	 * @filter rwmb_meta_boxes
	 */
	public function register()
	{
		if( current_user_can( 'switch_themes' )) {
			$this->addInstructions();
		}
		$metaboxes = func_num_args()
			? $this->toArray( func_get_arg(0) )
			: [];
		return array_merge( $metaboxes, $this->metaboxes );
	}

	/**
	 * @return bool
	 */
	public function verifyMetaBoxCondition( array $conditions )
	{
		array_walk( $conditions, function( &$value, $key ) {
			$method = $this->app->buildMethodName( $key, 'validate' );
			$value = method_exists( $this, $method )
				? $this->$method( $value )
				: $this->validateUnknown( $key, $value );
		});
		return !in_array( false, $conditions );
	}

	/**
	 * @return void
	 */
	protected function addInstructions()
	{
		if( !count( array_filter( $this->metaboxes, function( $metabox ) {
			return $this->isVisible( false, $metabox );
		})))return;
		$this->metaboxes[] = [
			'id' => 'infodiv',
			'post_types' => $this->getPostTypes(),
			'title' => __( 'How to use in your theme', 'pollux' ),
			'context' => 'side',
			'priority' => 'low',
			'fields' => [[
				'slug' => '',
				'std' => $this->generateInstructions(),
				'type' => 'custom_html',
			]],
		];
	}

	/**
	 * @return string
	 */
	protected function generateInstructions()
	{
		return array_reduce( $this->getInstructions(), function( $html, $metabox ) {
			$fields = array_reduce( array_column( $metabox['fields'], 'slug' ), function( $html, $slug ) use( $metabox ) {
				$hook = sprintf( 'pollux/%s/instruction', $this->getClassname() );
				return $html . apply_filters( $hook, "PostMeta::get('{$slug}');", $slug, $metabox['slug'] ) . PHP_EOL;
			});
			return $html . sprintf( '<p><strong>%s</strong></p><pre class="my-sites nav-tab-active misc-pub-section">%s</pre>',
				$metabox['title'],
				$fields
			);
		});
	}

	/**
	 * @return array
	 */
	protected function getInstructions()
	{
		return array_filter( $this->metaboxes, function( $metabox ) {
			return $this->verifyMetaBoxCondition( $metabox['condition'] )
				&& $this->hasPostType( $metabox );
		});
	}

	/**
	 * @return int
	 */
	protected function getPostId()
	{
		if( !( $postId = filter_input( INPUT_GET, 'post' ))) {
			$postId = filter_input( INPUT_POST, 'post_ID' );
		}
		return intval( $postId );
	}

	/**
	 * @return array
	 */
	protected function getPostTypes()
	{
		return array_unique( iterator_to_array(
			new RecursiveIteratorIterator(
				new RecursiveArrayIterator( array_column( $this->metaboxes, 'post_types' ))
			),
			false
		));
	}

	/**
	 * @return bool
	 */
	protected function hasPostType( array $metabox )
	{
		if( !isset( $metabox['post_types'] )) {
			return true;
		}
		return in_array( get_post_type( $this->getPostId() ), $metabox['post_types'] );
	}

	/**
	 * {@inheritdoc}
	 */
	protected function normalize()
	{
		foreach( $this->app->config['meta_boxes'] as $id => $metabox ) {
			$defaults = [
				'condition' => [],
				'fields' => [],
				'id' => $id,
				'post_types' => [],
				'slug' => $id,
			];
			$this->metaboxes[] = $this->setDependencies(
				$this->normalizeThis( $metabox, $defaults, $id )
			);
		}
	}

	/**
	 * @param mixed $conditions
	 * @return array
	 */
	protected function normalizeCondition( $conditions )
	{
		$conditions = $this->toArray( $conditions );
		if( count( array_filter( array_keys( $conditions ), 'is_string' )) == 0 ) {
			foreach( $conditions as $key ) {
				$conditions[str_replace( '!', '', $key )] = substr( $key, 0, 1 ) == '!' ? 0 : 1;
			}
			$conditions = array_filter( $conditions, function( $key ) {
				return !is_numeric( $key );
			}, ARRAY_FILTER_USE_KEY );
		}
		$hook = sprintf( 'pollux/%s/conditions', $this->getClassname() );
		return array_intersect_key(
			$conditions,
			array_flip( apply_filters( $hook, static::CONDITIONS ))
		);
	}

	/**
	 * @param string $id

There is no parameter named $id. Was it maybe removed?

	 * @param string $parentId
	 * @return string
	 */
	protected function normalizeDepends( $depends, array $data, $parentId )
	{
		return is_string( $depends ) && !empty( $depends )
			? $this->normalizeId( $depends, $data, $parentId )
			: '';
	}

	/**
	 * @return array
	 */
	protected function normalizeFields( array $fields, array $data, $parentId )
	{
		return array_map( function( $id, $field ) use( $parentId ) {
			$defaults =  [
				'attributes' => [],
				// 'condition' => [],

63% of this comment could be valid code. Did you maybe forget this after debugging?

				'depends' => '',
				'id' => $id,
				'field_name' => '',
				'slug' => $id,
			];
			return $this->normalizeThis( $field, $defaults, $parentId );
		}, array_keys( $fields ), $fields );
	}

	/**
	 * @param string $id
	 * @param string $parentId
	 * @return string
	 */
	protected function normalizeId( $id, array $data, $parentId )
	{
		return apply_filters( 'pollux/prefix', Application::PREFIX ) . $id;
	}

	/**
	 * @param mixed $types
	 * @return array
	 */
	protected function normalizePostTypes( $types )
	{
		return $this->toArray( $types );
	}

	/**
	 * @return array
	 */
	protected function setDependencies( array $metabox )
	{
		$fields = &$metabox['fields'];
		$depends = array_column( $fields, 'depends' );
		array_walk( $depends, function( $value, $index ) use( &$fields ) {
			if( empty( $value ))return;
			$fields[$index]['attributes']['data-depends'] = $value;
		});
		return $metabox;
	}

	/**
	 * @param string $value
	 * @return bool
	 */
	protected function validateClassExists( $value )
	{
		return class_exists( $value );
	}

	/**
	 * @param string $value
	 * @return bool
	 */
	protected function validateDefined( $value )
	{
		return defined( $value );
	}

	/**
	 * @param string $value
	 * @return bool
	 */
	protected function validateFunctionExists( $value )
	{
		return function_exists( $value );
	}

	/**
	 * @param string $value
	 * @return bool
	 */
	protected function validateHook( $value )
	{
		return apply_filters( $value, true );
	}

	/**
	 * @param bool $value
	 * @return bool
	 */
	protected function validateIsFrontPage( $value )
	{
		return $value == ( $this->getPostId() == get_option( 'page_on_front' ));
	}

	/**
	 * @param bool $value
	 * @return bool
	 */
	protected function validateIsHome( $value )
	{
		return $value == ( $this->getPostId() == get_option( 'page_for_posts' ));
	}

	/**
	 * @param string $value
	 * @return bool
	 */
	protected function validateIsPageTemplate( $value )
	{
		return basename( get_page_template_slug( $this->getPostId() )) == $value;
	}

	/**
	 * @param string $value
	 * @return bool
	 */
	protected function validateIsPluginActive( $value )
	{
		return is_plugin_active( $value );
	}

	/**
	 * @param string $value
	 * @return bool
	 */
	protected function validateIsPluginInactive( $value )
	{
		return is_plugin_inactive( $value );
	}

	/**
	 * @param string $key
	 * @param mixed $value
	 * @return bool
	 */
	protected function validateUnknown( $key, $value )
	{
		return apply_filters( 'pollux/metabox/condition', true, $key, $value );
	}
}