Container_Condition_Provider - Code Metrics - htmlburger/carbon-fields - Measure and Improve Code Quality continuously with Scrutinizer

Container_Condition_Provider A
last analyzed 2021-04-22 13:52 UTC

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	368
Duplicated Lines	8.7 %

Coupling/Cohesion

Components	1
Dependencies	31

Test Coverage

Coverage

Importance

Changes

Metric	Value
dl	32
loc	368
ccs	0
cts	183
cp	0
rs	10
c	0
b	0
f	0
wmc	12
lcom	1
cbo	31

12 Methods

Rating	Name	Duplication	Size	Complexity
A	register()	0	6	1
A	install_translators()	0	9	1
A	install_container_conditions()	0	21	1
B	install_conditions()	32	140	1
B	install_comparers()	0	56	1
A	filter_post_meta_container_static_condition_types()	0	6	1
A	filter_post_meta_container_dynamic_condition_types()	0	6	1
A	filter_term_meta_container_static_condition_types()	0	6	1
A	filter_term_meta_container_dynamic_condition_types()	0	6	1
A	filter_user_meta_container_static_condition_types()	0	6	1
A	filter_user_meta_container_dynamic_condition_types()	0	6	1
A	filter_theme_options_container_static_condition_types()	0	6	1

How to fix Duplicated Code

<?php

namespace Carbon_Fields\Provider;

use Carbon_Fields\Pimple\Container as PimpleContainer;
use Carbon_Fields\Pimple\ServiceProviderInterface;
use Carbon_Fields\Container\Condition\Factory as ConditionFactory;
use Carbon_Fields\Container\Fulfillable\Fulfillable_Collection;

class Container_Condition_Provider implements ServiceProviderInterface {

	/**
	 * Install dependencies in IoC container
	 *
	 * @param  PimpleContainer $ioc
	 */
	public function register( PimpleContainer $ioc ) {
		$this->install_conditions( $ioc );
		$this->install_comparers( $ioc );
		$this->install_translators( $ioc );
		$this->install_container_conditions( $ioc );
	}

	/**
	 * Install all codition types and the condition factory
	 *
	 * @param  PimpleContainer $ioc
	 */
	protected function install_conditions( $ioc ) {
		$ioc['container_condition_factory'] = function( $ioc ) {
			return new ConditionFactory( $ioc['container_conditions'] );
		};

		$ioc['container_condition_fulfillable_collection'] = $ioc->factory( function( $ioc ) {
			return new Fulfillable_Collection( $ioc['container_condition_factory'], $ioc['container_condition_translator_array'] );
		} );

		$ioc['container_conditions'] = function() {
			return new PimpleContainer();
		};

		$cc_ioc = $ioc['container_conditions'];

		$cc_ioc['boolean'] = $cc_ioc->factory( function() use ( $ioc ) {
			$condition = new \Carbon_Fields\Container\Condition\Boolean_Condition();
			$condition->set_comparers( array(
				$ioc['container_condition_comparers']['equality'],
			) );
			return $condition;
		} );

		$cc_ioc['post_id'] = $cc_ioc->factory( function() use ( $ioc ) {
			$condition = new \Carbon_Fields\Container\Condition\Post_ID_Condition();
			$condition->set_comparers( $ioc['container_condition_comparer_collections']['generic'] );
			return $condition;
		} );
		$cc_ioc['post_parent_id'] = $cc_ioc->factory( function() use ( $ioc ) {
			$condition = new \Carbon_Fields\Container\Condition\Post_Parent_ID_Condition();
			$condition->set_comparers( $ioc['container_condition_comparer_collections']['generic'] );
			return $condition;
		} );
		$cc_ioc['post_ancestor_id'] = $cc_ioc->factory( function() use ( $ioc ) {
			$condition = new \Carbon_Fields\Container\Condition\Post_Ancestor_ID_Condition();
			$condition->set_comparers( $ioc['container_condition_comparer_collections']['array'] );
			return $condition;
		} );
		$cc_ioc['post_type'] = $cc_ioc->factory( function() use ( $ioc ) {
			$condition = new \Carbon_Fields\Container\Condition\Post_Type_Condition();
			$condition->set_comparers( $ioc['container_condition_comparer_collections']['nonscalar'] );
			return $condition;
		} );
		$cc_ioc['post_format'] = $cc_ioc->factory( function() use ( $ioc ) {
			$condition = new \Carbon_Fields\Container\Condition\Post_Format_Condition();
			$condition->set_comparers( $ioc['container_condition_comparer_collections']['nonscalar'] );
			return $condition;
		} );
		$cc_ioc['post_level'] = $cc_ioc->factory( function() use ( $ioc ) {
			$condition = new \Carbon_Fields\Container\Condition\Post_Level_Condition();
			$condition->set_comparers( $ioc['container_condition_comparer_collections']['generic'] );
			return $condition;
		} );
		$cc_ioc['post_template'] = $cc_ioc->factory( function() use ( $ioc ) {
			$condition = new \Carbon_Fields\Container\Condition\Post_Template_Condition();
			$condition->set_comparers( $ioc['container_condition_comparer_collections']['nonscalar'] );
			return $condition;
		} );
		$cc_ioc['post_term'] = $cc_ioc->factory( function() use ( $ioc ) {
			$condition = new \Carbon_Fields\Container\Condition\Post_Term_Condition( $ioc['wp_toolset'] );
			$condition->set_comparers( array(
				// Only support the custom comparer as this condition has its own comparison methods
				$ioc['container_condition_comparers']['custom'],
			) );
			return $condition;
		} );

		$cc_ioc['term'] = $cc_ioc->factory( function() use ( $ioc ) {
			$condition = new \Carbon_Fields\Container\Condition\Term_Condition( $ioc['wp_toolset'] );
			$condition->set_comparers( array(
				// Only support the custom comparer as this condition has its own comparison methods
				$ioc['container_condition_comparers']['custom'],
			) );
			return $condition;
		} );
		$cc_ioc['term_taxonomy'] = $cc_ioc->factory( function() use ( $ioc ) {
			$condition = new \Carbon_Fields\Container\Condition\Term_Taxonomy_Condition();
			$condition->set_comparers( $ioc['container_condition_comparer_collections']['nonscalar'] );
			return $condition;
		} );
		$cc_ioc['term_level'] = $cc_ioc->factory( function() use ( $ioc ) {
			$condition = new \Carbon_Fields\Container\Condition\Term_Level_Condition();
			$condition->set_comparers( $ioc['container_condition_comparer_collections']['generic'] );
			return $condition;
		} );
		$cc_ioc['term_parent'] = $cc_ioc->factory( function() use ( $ioc ) {
			$condition = new \Carbon_Fields\Container\Condition\Term_Parent_Condition( $ioc['wp_toolset'] );
			$condition->set_comparers( $ioc['container_condition_comparer_collections']['generic'] );
			return $condition;
		} );
		$cc_ioc['term_ancestor'] = $cc_ioc->factory( function() use ( $ioc ) {
			$condition = new \Carbon_Fields\Container\Condition\Term_Ancestor_Condition( $ioc['wp_toolset'] );
			$condition->set_comparers( $ioc['container_condition_comparer_collections']['array'] );
			return $condition;
		} );

		$cc_ioc['user_id'] = $cc_ioc->factory( function() use ( $ioc ) {
			$condition = new \Carbon_Fields\Container\Condition\User_ID_Condition();
			$condition->set_comparers( $ioc['container_condition_comparer_collections']['generic'] );
			return $condition;
		} );
		$cc_ioc['user_role'] = $cc_ioc->factory( function() use ( $ioc ) {
			$condition = new \Carbon_Fields\Container\Condition\User_Role_Condition();
			$condition->set_comparers( $ioc['container_condition_comparer_collections']['array'] );
			return $condition;
		} );
		$cc_ioc['user_capability'] = $cc_ioc->factory( function() use ( $ioc ) {
			$condition = new \Carbon_Fields\Container\Condition\User_Capability_Condition();
			$condition->set_comparers( array(
				// Only support the custom comparer as this condition has its own comparison methods
				$ioc['container_condition_comparers']['custom'],
			) );
			return $condition;
		} );

		$cc_ioc['blog_id'] = $cc_ioc->factory( function() use ( $ioc ) {
			$condition = new \Carbon_Fields\Container\Condition\Blog_ID_Condition();
			$condition->set_comparers( $ioc['container_condition_comparer_collections']['generic'] );
			return $condition;
		} );

		$cc_ioc['current_user_id'] = $cc_ioc->factory( function() use ( $ioc ) {
			$condition = new \Carbon_Fields\Container\Condition\Current_User_ID_Condition();
			$condition->set_comparers( $ioc['container_condition_comparer_collections']['generic'] );
			return $condition;
		} );
		$cc_ioc['current_user_role'] = $cc_ioc->factory( function() use ( $ioc ) {
			$condition = new \Carbon_Fields\Container\Condition\Current_User_Role_Condition();
			$condition->set_comparers( $ioc['container_condition_comparer_collections']['array'] );
			return $condition;
		} );
		$cc_ioc['current_user_capability'] = $cc_ioc->factory( function() use ( $ioc ) {
			$condition = new \Carbon_Fields\Container\Condition\Current_User_Capability_Condition();
			$condition->set_comparers( array(
				// Only support the custom comparer as this condition has its own comparison methods
				$ioc['container_condition_comparers']['custom'],
			) );
			return $condition;
		} );
	}

	/**
	 * Install all condition comparers
	 *
	 * @param  PimpleContainer $ioc
	 */
	protected function install_comparers( $ioc ) {
		$ioc['container_condition_comparers'] = function() {
			return new PimpleContainer();
		};

		$ioc['container_condition_comparers']['equality'] = function() {
			return new \Carbon_Fields\Container\Condition\Comparer\Equality_Comparer();
		};

		$ioc['container_condition_comparers']['any_equality'] = function() {
			return new \Carbon_Fields\Container\Condition\Comparer\Any_Equality_Comparer();
		};

		$ioc['container_condition_comparers']['contain'] = function() {
			return new \Carbon_Fields\Container\Condition\Comparer\Contain_Comparer();
		};

		$ioc['container_condition_comparers']['any_contain'] = function() {
			return new \Carbon_Fields\Container\Condition\Comparer\Any_Contain_Comparer();
		};

		$ioc['container_condition_comparers']['scalar'] = function() {
			return new \Carbon_Fields\Container\Condition\Comparer\Scalar_Comparer();
		};

		$ioc['container_condition_comparers']['custom'] = function() {
			return new \Carbon_Fields\Container\Condition\Comparer\Custom_Comparer();
		};

		$ioc['container_condition_comparer_collections'] = function() {
			return new PimpleContainer();
		};

		$ioc['container_condition_comparer_collections']['generic'] = function() use ( $ioc ) {
			return array(
				$ioc['container_condition_comparers']['equality'],
				$ioc['container_condition_comparers']['contain'],
				$ioc['container_condition_comparers']['scalar'],
				$ioc['container_condition_comparers']['custom'],
			);
		};
		$ioc['container_condition_comparer_collections']['nonscalar'] = function() use ( $ioc ) {
			return array(
				$ioc['container_condition_comparers']['equality'],
				$ioc['container_condition_comparers']['contain'],
				$ioc['container_condition_comparers']['custom'],
			);
		};
		$ioc['container_condition_comparer_collections']['array'] = function() use ( $ioc ) {
			return array(
				$ioc['container_condition_comparers']['any_equality'],
				$ioc['container_condition_comparers']['any_contain'],
				$ioc['container_condition_comparers']['custom'],
			);
		};
	}

	/**
	 * Install all codition translators
	 *
	 * @param  PimpleContainer $ioc
	 */
	protected static function install_translators( $ioc ) {
		$ioc['container_condition_translator_array'] = function( $ioc ) {
			return new \Carbon_Fields\Container\Fulfillable\Translator\Array_Translator( $ioc['container_condition_factory'] );
		};

		$ioc['container_condition_translator_json'] = function( $ioc ) {
			return new \Carbon_Fields\Container\Fulfillable\Translator\Json_Translator( $ioc['container_condition_factory'] );
		};
	}

	/**
	 * Install all container coditions
	 *
	 * @param  PimpleContainer $ioc
	 */
	protected function install_container_conditions( $ioc ) {
		// add current_user_* static condition types to all containers
		add_filter( 'carbon_fields_container_static_condition_types', function( $condition_types, $container_type, $container ) {
			return array_merge(
				$condition_types,
				array( 'current_user_id', 'current_user_role', 'current_user_capability' )
			);
		}, 10, 3 );

		// add container-specific conditions
		add_filter( 'carbon_fields_post_meta_container_static_condition_types', array( $this, 'filter_post_meta_container_static_condition_types' ), 10, 3 );
		add_filter( 'carbon_fields_post_meta_container_dynamic_condition_types', array( $this, 'filter_post_meta_container_dynamic_condition_types' ), 10, 3 );

		add_filter( 'carbon_fields_term_meta_container_static_condition_types', array( $this, 'filter_term_meta_container_static_condition_types' ), 10, 3 );
		add_filter( 'carbon_fields_term_meta_container_dynamic_condition_types', array( $this, 'filter_term_meta_container_dynamic_condition_types' ), 10, 3 );

		add_filter( 'carbon_fields_user_meta_container_static_condition_types', array( $this, 'filter_user_meta_container_static_condition_types' ), 10, 3 );
		add_filter( 'carbon_fields_user_meta_container_dynamic_condition_types', array( $this, 'filter_user_meta_container_dynamic_condition_types' ), 10, 3 );

		add_filter( 'carbon_fields_theme_options_container_static_condition_types', array( $this, 'filter_theme_options_container_static_condition_types' ), 10, 3 );
	}

	/**
	 * Filter the Post_Meta_Container static condition types
	 *
	 * @param  array<string>                     $condition_types
	 * @param  \Carbon_Fields\Container\Container $container
	 * @return array<string>
	 */
	public function filter_post_meta_container_static_condition_types( $condition_types, $container_type, $container ) {
		return array_merge(
			$condition_types,
			array( 'post_id', 'post_type' )
		);
	}

	/**
	 * Filter the Post_Meta_Container dynamic condition types
	 *
	 * @param  array<string>                      $condition_types
	 * @param  string                             $container_type
	 * @param  \Carbon_Fields\Container\Container $container
	 * @return array<string>
	 */
	public function filter_post_meta_container_dynamic_condition_types( $condition_types, $container_type, $container ) {
		return array_merge(
			$condition_types,
			array( 'post_parent_id', 'post_ancestor_id', 'post_format', 'post_level', 'post_template', 'post_term' )
		);
	}

	/**
	 * Filter the Term_Meta_Container static condition types
	 *
	 * @param  array<string>                      $condition_types
	 * @param  string                             $container_type
	 * @param  \Carbon_Fields\Container\Container $container
	 * @return array<string>
	 */
	public function filter_term_meta_container_static_condition_types( $condition_types, $container_type, $container ) {
		return array_merge(
			$condition_types,
			array( 'term', 'term_taxonomy' )
		);
	}

	/**
	 * Filter the Term_Meta_Container dynamic condition types
	 *
	 * @param  array<string>                      $condition_types
	 * @param  string                             $container_type
	 * @param  \Carbon_Fields\Container\Container $container
	 * @return array<string>
	 */
	public function filter_term_meta_container_dynamic_condition_types( $condition_types, $container_type, $container ) {
		return array_merge(
			$condition_types,
			array( 'term_level', 'term_parent', 'term_ancestor' )
		);
	}

	/**
	 * Filter the User_Meta_Container static condition types
	 *
	 * @param  array<string>                      $condition_types
	 * @param  string                             $container_type
	 * @param  \Carbon_Fields\Container\Container $container
	 * @return array<string>
	 */
	public function filter_user_meta_container_static_condition_types( $condition_types, $container_type, $container ) {
		return array_merge(
			$condition_types,
			array( 'user_id', 'user_capability' )
		);
	}

	/**
	 * Filter the User_Meta_Container dynamic condition types
	 *
	 * @param  array<string>                      $condition_types
	 * @param  string                             $container_type
	 * @param  \Carbon_Fields\Container\Container $container
	 * @return array<string>
	 */
	public function filter_user_meta_container_dynamic_condition_types( $condition_types, $container_type, $container ) {
		return array_merge(
			$condition_types,
			array( 'user_role' )
		);
	}

	/**
	 * Filter the Theme_Options_Container static condition types
	 *
	 * @param  array<string>                      $condition_types
	 * @param  string                             $container_type
	 * @param  \Carbon_Fields\Container\Container $container
	 * @return array<string>
	 */
	public function filter_theme_options_container_static_condition_types( $condition_types, $container_type, $container ) {
		return array_merge(
			$condition_types,
			array( 'blog_id' )
		);
	}
}


1		<?php
2
3		namespace Carbon_Fields\Provider;
4
5		use Carbon_Fields\Pimple\Container as PimpleContainer;
6		use Carbon_Fields\Pimple\ServiceProviderInterface;
7		use Carbon_Fields\Container\Condition\Factory as ConditionFactory;
8		use Carbon_Fields\Container\Fulfillable\Fulfillable_Collection;
9
10		class Container_Condition_Provider implements ServiceProviderInterface {
11
12		/**
13		* Install dependencies in IoC container
14		*
15		* @param PimpleContainer $ioc
16		*/
17		public function register( PimpleContainer $ioc ) {
18		$this->install_conditions( $ioc );
19		$this->install_comparers( $ioc );
20		$this->install_translators( $ioc );
21		$this->install_container_conditions( $ioc );
22		}
23
24		/**
25		* Install all codition types and the condition factory
26		*
27		* @param PimpleContainer $ioc
28		*/
29		protected function install_conditions( $ioc ) {
30		$ioc['container_condition_factory'] = function( $ioc ) {
31		return new ConditionFactory( $ioc['container_conditions'] );
32		};
33
34		$ioc['container_condition_fulfillable_collection'] = $ioc->factory( function( $ioc ) {
35		return new Fulfillable_Collection( $ioc['container_condition_factory'], $ioc['container_condition_translator_array'] );
36		} );
37
38		$ioc['container_conditions'] = function() {
39		return new PimpleContainer();
40		};
41
42		$cc_ioc = $ioc['container_conditions'];
43
44		$cc_ioc['boolean'] = $cc_ioc->factory( function() use ( $ioc ) {
45		$condition = new \Carbon_Fields\Container\Condition\Boolean_Condition();
46		$condition->set_comparers( array(
47		$ioc['container_condition_comparers']['equality'],
48		) );
49		return $condition;
50		} );
51
52		$cc_ioc['post_id'] = $cc_ioc->factory( function() use ( $ioc ) {
53		$condition = new \Carbon_Fields\Container\Condition\Post_ID_Condition();
54		$condition->set_comparers( $ioc['container_condition_comparer_collections']['generic'] );
55		return $condition;
56		} );
57		$cc_ioc['post_parent_id'] = $cc_ioc->factory( function() use ( $ioc ) {
58		$condition = new \Carbon_Fields\Container\Condition\Post_Parent_ID_Condition();
59		$condition->set_comparers( $ioc['container_condition_comparer_collections']['generic'] );
60		return $condition;
61		} );
62		$cc_ioc['post_ancestor_id'] = $cc_ioc->factory( function() use ( $ioc ) {
63		$condition = new \Carbon_Fields\Container\Condition\Post_Ancestor_ID_Condition();
64		$condition->set_comparers( $ioc['container_condition_comparer_collections']['array'] );
65		return $condition;
66		} );
67		$cc_ioc['post_type'] = $cc_ioc->factory( function() use ( $ioc ) {
68		$condition = new \Carbon_Fields\Container\Condition\Post_Type_Condition();
69		$condition->set_comparers( $ioc['container_condition_comparer_collections']['nonscalar'] );
70		return $condition;
71		} );
72		$cc_ioc['post_format'] = $cc_ioc->factory( function() use ( $ioc ) {
73		$condition = new \Carbon_Fields\Container\Condition\Post_Format_Condition();
74		$condition->set_comparers( $ioc['container_condition_comparer_collections']['nonscalar'] );
75		return $condition;
76		} );
77		$cc_ioc['post_level'] = $cc_ioc->factory( function() use ( $ioc ) {
78		$condition = new \Carbon_Fields\Container\Condition\Post_Level_Condition();
79		$condition->set_comparers( $ioc['container_condition_comparer_collections']['generic'] );
80		return $condition;
81		} );
82		$cc_ioc['post_template'] = $cc_ioc->factory( function() use ( $ioc ) {
83		$condition = new \Carbon_Fields\Container\Condition\Post_Template_Condition();
84		$condition->set_comparers( $ioc['container_condition_comparer_collections']['nonscalar'] );
85		return $condition;
86		} );
87	View Code Duplication	$cc_ioc['post_term'] = $cc_ioc->factory( function() use ( $ioc ) {
88		$condition = new \Carbon_Fields\Container\Condition\Post_Term_Condition( $ioc['wp_toolset'] );
89		$condition->set_comparers( array(
90		// Only support the custom comparer as this condition has its own comparison methods
91		$ioc['container_condition_comparers']['custom'],
92		) );
93		return $condition;
94		} );
95
96	View Code Duplication	$cc_ioc['term'] = $cc_ioc->factory( function() use ( $ioc ) {
97		$condition = new \Carbon_Fields\Container\Condition\Term_Condition( $ioc['wp_toolset'] );
98		$condition->set_comparers( array(
99		// Only support the custom comparer as this condition has its own comparison methods
100		$ioc['container_condition_comparers']['custom'],
101		) );
102		return $condition;
103		} );
104		$cc_ioc['term_taxonomy'] = $cc_ioc->factory( function() use ( $ioc ) {
105		$condition = new \Carbon_Fields\Container\Condition\Term_Taxonomy_Condition();
106		$condition->set_comparers( $ioc['container_condition_comparer_collections']['nonscalar'] );
107		return $condition;
108		} );
109		$cc_ioc['term_level'] = $cc_ioc->factory( function() use ( $ioc ) {
110		$condition = new \Carbon_Fields\Container\Condition\Term_Level_Condition();
111		$condition->set_comparers( $ioc['container_condition_comparer_collections']['generic'] );
112		return $condition;
113		} );
114		$cc_ioc['term_parent'] = $cc_ioc->factory( function() use ( $ioc ) {
115		$condition = new \Carbon_Fields\Container\Condition\Term_Parent_Condition( $ioc['wp_toolset'] );
116		$condition->set_comparers( $ioc['container_condition_comparer_collections']['generic'] );
117		return $condition;
118		} );
119		$cc_ioc['term_ancestor'] = $cc_ioc->factory( function() use ( $ioc ) {
120		$condition = new \Carbon_Fields\Container\Condition\Term_Ancestor_Condition( $ioc['wp_toolset'] );
121		$condition->set_comparers( $ioc['container_condition_comparer_collections']['array'] );
122		return $condition;
123		} );
124
125		$cc_ioc['user_id'] = $cc_ioc->factory( function() use ( $ioc ) {
126		$condition = new \Carbon_Fields\Container\Condition\User_ID_Condition();
127		$condition->set_comparers( $ioc['container_condition_comparer_collections']['generic'] );
128		return $condition;
129		} );
130		$cc_ioc['user_role'] = $cc_ioc->factory( function() use ( $ioc ) {
131		$condition = new \Carbon_Fields\Container\Condition\User_Role_Condition();
132		$condition->set_comparers( $ioc['container_condition_comparer_collections']['array'] );
133		return $condition;
134		} );
135	View Code Duplication	$cc_ioc['user_capability'] = $cc_ioc->factory( function() use ( $ioc ) {
136		$condition = new \Carbon_Fields\Container\Condition\User_Capability_Condition();
137		$condition->set_comparers( array(
138		// Only support the custom comparer as this condition has its own comparison methods
139		$ioc['container_condition_comparers']['custom'],
140		) );
141		return $condition;
142		} );
143
144		$cc_ioc['blog_id'] = $cc_ioc->factory( function() use ( $ioc ) {
145		$condition = new \Carbon_Fields\Container\Condition\Blog_ID_Condition();
146		$condition->set_comparers( $ioc['container_condition_comparer_collections']['generic'] );
147		return $condition;
148		} );
149
150		$cc_ioc['current_user_id'] = $cc_ioc->factory( function() use ( $ioc ) {
151		$condition = new \Carbon_Fields\Container\Condition\Current_User_ID_Condition();
152		$condition->set_comparers( $ioc['container_condition_comparer_collections']['generic'] );
153		return $condition;
154		} );
155		$cc_ioc['current_user_role'] = $cc_ioc->factory( function() use ( $ioc ) {
156		$condition = new \Carbon_Fields\Container\Condition\Current_User_Role_Condition();
157		$condition->set_comparers( $ioc['container_condition_comparer_collections']['array'] );
158		return $condition;
159		} );
160	View Code Duplication	$cc_ioc['current_user_capability'] = $cc_ioc->factory( function() use ( $ioc ) {
161		$condition = new \Carbon_Fields\Container\Condition\Current_User_Capability_Condition();
162		$condition->set_comparers( array(
163		// Only support the custom comparer as this condition has its own comparison methods
164		$ioc['container_condition_comparers']['custom'],
165		) );
166		return $condition;
167		} );
168		}
169
170		/**
171		* Install all condition comparers
172		*
173		* @param PimpleContainer $ioc
174		*/
175		protected function install_comparers( $ioc ) {
176		$ioc['container_condition_comparers'] = function() {
177		return new PimpleContainer();
178		};
179
180		$ioc['container_condition_comparers']['equality'] = function() {
181		return new \Carbon_Fields\Container\Condition\Comparer\Equality_Comparer();
182		};
183
184		$ioc['container_condition_comparers']['any_equality'] = function() {
185		return new \Carbon_Fields\Container\Condition\Comparer\Any_Equality_Comparer();
186		};
187
188		$ioc['container_condition_comparers']['contain'] = function() {
189		return new \Carbon_Fields\Container\Condition\Comparer\Contain_Comparer();
190		};
191
192		$ioc['container_condition_comparers']['any_contain'] = function() {
193		return new \Carbon_Fields\Container\Condition\Comparer\Any_Contain_Comparer();
194		};
195
196		$ioc['container_condition_comparers']['scalar'] = function() {
197		return new \Carbon_Fields\Container\Condition\Comparer\Scalar_Comparer();
198		};
199
200		$ioc['container_condition_comparers']['custom'] = function() {
201		return new \Carbon_Fields\Container\Condition\Comparer\Custom_Comparer();
202		};
203
204		$ioc['container_condition_comparer_collections'] = function() {
205		return new PimpleContainer();
206		};
207
208		$ioc['container_condition_comparer_collections']['generic'] = function() use ( $ioc ) {
209		return array(
210		$ioc['container_condition_comparers']['equality'],
211		$ioc['container_condition_comparers']['contain'],
212		$ioc['container_condition_comparers']['scalar'],
213		$ioc['container_condition_comparers']['custom'],
214		);
215		};
216		$ioc['container_condition_comparer_collections']['nonscalar'] = function() use ( $ioc ) {
217		return array(
218		$ioc['container_condition_comparers']['equality'],
219		$ioc['container_condition_comparers']['contain'],
220		$ioc['container_condition_comparers']['custom'],
221		);
222		};
223		$ioc['container_condition_comparer_collections']['array'] = function() use ( $ioc ) {
224		return array(
225		$ioc['container_condition_comparers']['any_equality'],
226		$ioc['container_condition_comparers']['any_contain'],
227		$ioc['container_condition_comparers']['custom'],
228		);
229		};
230		}
231
232		/**
233		* Install all codition translators
234		*
235		* @param PimpleContainer $ioc
236		*/
237		protected static function install_translators( $ioc ) {
238		$ioc['container_condition_translator_array'] = function( $ioc ) {
239		return new \Carbon_Fields\Container\Fulfillable\Translator\Array_Translator( $ioc['container_condition_factory'] );
240		};
241
242		$ioc['container_condition_translator_json'] = function( $ioc ) {
243		return new \Carbon_Fields\Container\Fulfillable\Translator\Json_Translator( $ioc['container_condition_factory'] );
244		};
245		}
246
247		/**
248		* Install all container coditions
249		*
250		* @param PimpleContainer $ioc
251		*/
252		protected function install_container_conditions( $ioc ) {
253		// add current_user_* static condition types to all containers
254		add_filter( 'carbon_fields_container_static_condition_types', function( $condition_types, $container_type, $container ) {
255		return array_merge(
256		$condition_types,
257		array( 'current_user_id', 'current_user_role', 'current_user_capability' )
258		);
259		}, 10, 3 );
260
261		// add container-specific conditions
262		add_filter( 'carbon_fields_post_meta_container_static_condition_types', array( $this, 'filter_post_meta_container_static_condition_types' ), 10, 3 );
263		add_filter( 'carbon_fields_post_meta_container_dynamic_condition_types', array( $this, 'filter_post_meta_container_dynamic_condition_types' ), 10, 3 );
264
265		add_filter( 'carbon_fields_term_meta_container_static_condition_types', array( $this, 'filter_term_meta_container_static_condition_types' ), 10, 3 );
266		add_filter( 'carbon_fields_term_meta_container_dynamic_condition_types', array( $this, 'filter_term_meta_container_dynamic_condition_types' ), 10, 3 );
267
268		add_filter( 'carbon_fields_user_meta_container_static_condition_types', array( $this, 'filter_user_meta_container_static_condition_types' ), 10, 3 );
269		add_filter( 'carbon_fields_user_meta_container_dynamic_condition_types', array( $this, 'filter_user_meta_container_dynamic_condition_types' ), 10, 3 );
270
271		add_filter( 'carbon_fields_theme_options_container_static_condition_types', array( $this, 'filter_theme_options_container_static_condition_types' ), 10, 3 );
272		}
273
274		/**
275		* Filter the Post_Meta_Container static condition types
276		*
277		* @param array<string> $condition_types
278		* @param \Carbon_Fields\Container\Container $container
279		* @return array<string>
280		*/
281		public function filter_post_meta_container_static_condition_types( $condition_types, $container_type, $container ) {
282		return array_merge(
283		$condition_types,
284		array( 'post_id', 'post_type' )
285		);
286		}
287
288		/**
289		* Filter the Post_Meta_Container dynamic condition types
290		*
291		* @param array<string> $condition_types
292		* @param string $container_type
293		* @param \Carbon_Fields\Container\Container $container
294		* @return array<string>
295		*/
296		public function filter_post_meta_container_dynamic_condition_types( $condition_types, $container_type, $container ) {
297		return array_merge(
298		$condition_types,
299		array( 'post_parent_id', 'post_ancestor_id', 'post_format', 'post_level', 'post_template', 'post_term' )
300		);
301		}
302
303		/**
304		* Filter the Term_Meta_Container static condition types
305		*
306		* @param array<string> $condition_types
307		* @param string $container_type
308		* @param \Carbon_Fields\Container\Container $container
309		* @return array<string>
310		*/
311		public function filter_term_meta_container_static_condition_types( $condition_types, $container_type, $container ) {
312		return array_merge(
313		$condition_types,
314		array( 'term', 'term_taxonomy' )
315		);
316		}
317
318		/**
319		* Filter the Term_Meta_Container dynamic condition types
320		*
321		* @param array<string> $condition_types
322		* @param string $container_type
323		* @param \Carbon_Fields\Container\Container $container
324		* @return array<string>
325		*/
326		public function filter_term_meta_container_dynamic_condition_types( $condition_types, $container_type, $container ) {
327		return array_merge(
328		$condition_types,
329		array( 'term_level', 'term_parent', 'term_ancestor' )
330		);
331		}
332
333		/**
334		* Filter the User_Meta_Container static condition types
335		*
336		* @param array<string> $condition_types
337		* @param string $container_type
338		* @param \Carbon_Fields\Container\Container $container
339		* @return array<string>
340		*/
341		public function filter_user_meta_container_static_condition_types( $condition_types, $container_type, $container ) {
342		return array_merge(
343		$condition_types,
344		array( 'user_id', 'user_capability' )
345		);
346		}
347
348		/**
349		* Filter the User_Meta_Container dynamic condition types
350		*
351		* @param array<string> $condition_types
352		* @param string $container_type
353		* @param \Carbon_Fields\Container\Container $container
354		* @return array<string>
355		*/
356		public function filter_user_meta_container_dynamic_condition_types( $condition_types, $container_type, $container ) {
357		return array_merge(
358		$condition_types,
359		array( 'user_role' )
360		);
361		}
362
363		/**
364		* Filter the Theme_Options_Container static condition types
365		*
366		* @param array<string> $condition_types
367		* @param string $container_type
368		* @param \Carbon_Fields\Container\Container $container
369		* @return array<string>
370		*/
371		public function filter_theme_options_container_static_condition_types( $condition_types, $container_type, $container ) {
372		return array_merge(
373		$condition_types,
374		array( 'blog_id' )
375		);
376		}
377		}
378

htmlburger / carbon-fields

Container_Condition_Provider A last analyzed 2021-04-22 13:52 UTC

Complexity

Size/Duplication

Coupling/Cohesion

Test Coverage

Importance

12 Methods

How to fix Duplicated Code

Duplicated Code

Duplication Side-by-Side

Filter issues like

Container_Condition_Provider A
last analyzed 2021-04-22 13:52 UTC