Form::add_field() - Code Metrics - Inspection of "Merge origin/master" - amarkal/amarkal-taxonomy - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 3e5a13...3a93f1 )

by Askupa

created 2017-03-22 05:02 UTC

Form::add_field() B

↳ Parent: Form

Complexity

Conditions	3
Paths	4

Size

Total Lines	27
Code Lines	14

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	3
eloc	14
nc	4
nop	3
dl	0
loc	27
rs	8.8571
c	0
b	0
f	0

<?php

namespace Amarkal\Taxonomy;

/**
 * WordPress taxonomy form utilities
 */
class Form
{
    /**
     * @var Singleton The reference to *Singleton* instance of this class
     */
    private static $instance;
    
    /**
     * @var Array Stores all the registered fields for each taxonomy
     */
    private $fields = array();
    
    /**
     * Returns the *Singleton* instance of this class.
     *
     * @return Singleton The *Singleton* instance.
     */
    public static function get_instance()
    {
        if( null === static::$instance ) 
class YourClass
{
    private static $someVariable;

    public static function getSomeVariable()
    {
        return static::$someVariable;
    }
}
        {
            static::$instance = new static();
class YourClass
{
    private static $someVariable;

    public static function getSomeVariable()
    {
        return static::$someVariable;
    }
}
        }
        return static::$instance;
class YourClass
{
    private static $someVariable;

    public static function getSomeVariable()
    {
        return static::$someVariable;
    }
}
    }
    
    /**
     * Add a form field to both the add & edit forms for a given taxonomy.
     * 
     * @param string $taxonomy_name
     * @param string $field_name
     * @param array $field_props
     * @throws \RuntimeException if duplicate names are registered under the same taxonomy
     */
    public function add_field( $taxonomy_name, $field_name, $field_props )
    {
        if( !isset($this->fields[$taxonomy_name]) )
        {
            // Add fields to taxonomy add and edit forms 
            add_action( "{$taxonomy_name}_add_form_fields", array($this, 'render_add_form') );
            add_action( "{$taxonomy_name}_edit_form_fields", array($this, 'render_edit_form') );
            
            // Save the data from taxonomy add and edit forms
            add_action( "create_{$taxonomy_name}", array($this, 'update_term') );
            add_action( "edited_{$taxonomy_name}", array($this, 'update_term') );
            
            // Modify the taxonomy term table
            add_filter( "manage_edit-{$taxonomy_name}_columns", array($this, 'modify_table_columns') );
            add_filter( "manage_{$taxonomy_name}_custom_column", array($this, 'modify_table_content'), 10, 3 );
            add_filter( "manage_edit-{$taxonomy_name}_sortable_columns", array($this, 'modify_table_sortable_columns') );
            add_filter( 'terms_clauses', array($this, 'sort_custom_column'), 10, 3 );
            
            $this->fields[$taxonomy_name] = array();
        }

        if( !isset($this->fields[$taxonomy_name][$field_name]))
        {
            $this->fields[$taxonomy_name][$field_name] = array_merge( $this->default_props(), $field_props );
        }
        else throw new \RuntimeException("A field named '$field_name' has already been registered in '$taxonomy_name'");
    }
    
    /**
     * Render the 'edit term' form for a given taxonomy
     * 
     * @param object $term Taxonomy term
     */
    public function render_edit_form( $term )
    {
        $fields = $this->fields[$term->taxonomy];
        
        foreach( $fields as $name => $props )
        {
            $props['name'] = $name;
            $props['term_id'] = $term->term_id;
            $field = new EditField($props);
            echo $field->render();
        }
    }
    
    /**
     * Render the 'add new term' form for a given taxonomy
     * 
     * @param string $taxonomy Taxonomy name
     */
    public function render_add_form( $taxonomy )
    {
        $fields = $this->fields[$taxonomy];
        
        foreach( $fields as $name => $props )
        {
            $props['name'] = $name;
            $field = new AddField($props);
            echo $field->render();
        }
    }
    
    /**
     * Update the meta values for a given term. Called once one of the add/edit
     * forms is saved.
     * 
     * @param type $term_id
     */
    function update_term( $term_id ) 
// 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);
    }
}
    {
        $term = \get_term( $term_id );
        
        foreach( $this->fields[$term->taxonomy] as $name => $props )
        {
            if( isset($_POST[$name]) )
            {
                update_term_meta($term_id, $name, filter_input(INPUT_POST, $name));
            }
        }
    }
    
    /**
     * Add additional columns to the term table.
     * 
     * @param array $columns
     * @return array
     */
    function modify_table_columns( $columns )

    {   
        foreach( $this->fields as $fields )
        {
            foreach( $fields as $name => $props )
            {
                if( $props['table']['show'] )
                {
                    $columns[$name] = $props['label'];
                }
            }
        }
        return $columns;
    }
    
    /**
     * Retrieve the data for a given column in the term table.
     * 
     * @see https://developer.wordpress.org/reference/hooks/manage_this-screen-taxonomy_custom_column/
     * 
     * @param type $content
     * @param type $column_name
     * @param type $term_id
     * @return type
     */
    function modify_table_content( $content, $column_name, $term_id )

    {   
        $term = \get_term($term_id);
        foreach( $this->fields as $taxonomy => $fields )
        {
            foreach( $fields as $name => $props )
            {
                if( $props['table']['show'] && 
                    $term->taxonomy === $taxonomy &&
                    $name === $column_name
                ) {
                    $content = \get_term_meta($term_id, $name, true);
                }
            }
        }
        return $content;
    }
    
    /**
     * Make custom table columns sortable.
     * 
     * @param array $columns
     * @return string
     */
    function modify_table_sortable_columns( $columns )

    {
        foreach( $this->fields as $taxonomy => $fields )
        {
            foreach( $fields as $name => $props )
            {
                if( $props['table']['show'] && 
                    $props['table']['sortable']
                ) {
                    $columns[$name] = $name;
                }
            }
        }
        return $columns;
    }
    
    /**
     * Modify terms_clauses to allow sorting custom WordPress Admin Table Columns by a custom Taxonomy Term meta
     * 
     * @see https://developer.wordpress.org/reference/hooks/terms_clauses/
     * 
     * @global type $wpdb
     * @param type $clauses
     * @param type $taxonomies
     * @param type $args
     * @return string
     */
    function sort_custom_column( $clauses, $taxonomies, $args )

    {
        foreach( $this->fields as $taxonomy => $fields )
        {
            // if( in_array($taxonomy, $args['taxonomy']) && 'icon' === $args['orderby'])

            foreach( $fields as $name => $props )
            {
                if( in_array($taxonomy, $args['taxonomy']) && 
                    $props['table']['show'] && 
                    $props['table']['sortable'] &&
                    $name === $args['orderby']
                )
                {
                    $this->modify_term_clauses( $clauses, $taxonomy, $name );
                }
            }
        }
        return $clauses;
    }
    
    /**
     * Modify the orderby clauses for a given taxonomy
     * 
     * @param array $clauses
     * @param string $taxonomy
     * @param string $termmeta
     */
    function modify_term_clauses( &$clauses, $taxonomy, $termmeta )

    {
        global $wpdb;
function myFunction($a, $b) {
    // Do something
}
        // tt refers to the $wpdb->term_taxonomy table
        $clauses['join'] .= " LEFT JOIN {$wpdb->termmeta} AS tm ON t.term_id = tm.term_id";
        $clauses['where'] = "tt.taxonomy = '{$taxonomy}' AND (tm.meta_key = '{$termmeta}' OR tm.meta_key IS NULL)";
        $clauses['orderby'] = "ORDER BY tm.meta_value";
    }
    
    /**
     * The default form field properties. This is merged with the user given 
     * properties. When the component is rendered, this will be merged with the
     * component's properties as well.
     * 
     * @return array
     */
    private function default_props()
    {
        return array(
            'type'          => null,
            'label'         => null,
            'description'   => null,
            'table'         => array(
                'show'      => false,
                'sortable'  => false
            )
        );
    }
}

Push — master ( 3e5a13...3a93f1 )

Form::add_field() B

Complexity

Size

Duplication

Importance

1. Pass all data via parameters

2. Create a class that maintains your state

1		<?php
2
3		namespace Amarkal\Taxonomy;
4
5		/**
6		* WordPress taxonomy form utilities
7		*/
8		class Form
9		{
10		/**
11		* @var Singleton The reference to Singleton instance of this class
12		*/
13		private static $instance;
14
15		/**
16		* @var Array Stores all the registered fields for each taxonomy
17		*/
18		private $fields = array();
19
20		/**
21		* Returns the Singleton instance of this class.
22		*
23		* @return Singleton The Singleton instance.
24		*/
25		public static function get_instance()
26		{
27		if( null === static::$instance )
		0 ignored issues – show Bug introduced 2017-03-21 18:14 UTC by Report Bug Copy Issue Report Since `$instance` is declared private, accessing it with `static` will lead to errors in possible sub-classes; consider using `self`, or increasing the visibility of `$instance` to at least protected. Let’s assume you have a class which uses late-static binding: class YourClass { private static $someVariable; public static function getSomeVariable() { return static::$someVariable; } } The code above will run fine in your PHP runtime. However, if you now create a sub-class and call the `getSomeVariable()` on that sub-class, you will receive a runtime error: class YourSubClass extends YourClass { } YourSubClass::getSomeVariable(); // Will cause an access error. In the case above, it makes sense to update `SomeClass` to use `self` instead: class SomeClass { private static $someVariable; public static function getSomeVariable() { return self::$someVariable; // self works fine with private. } } Loading history...
28		{
29		static::$instance = new static();
		0 ignored issues – show Bug introduced 2017-03-21 18:14 UTC by Report Bug Copy Issue Report Since `$instance` is declared private, accessing it with `static` will lead to errors in possible sub-classes; consider using `self`, or increasing the visibility of `$instance` to at least protected. Let’s assume you have a class which uses late-static binding: class YourClass { private static $someVariable; public static function getSomeVariable() { return static::$someVariable; } } The code above will run fine in your PHP runtime. However, if you now create a sub-class and call the `getSomeVariable()` on that sub-class, you will receive a runtime error: class YourSubClass extends YourClass { } YourSubClass::getSomeVariable(); // Will cause an access error. In the case above, it makes sense to update `SomeClass` to use `self` instead: class SomeClass { private static $someVariable; public static function getSomeVariable() { return self::$someVariable; // self works fine with private. } } Loading history... Documentation Bug introduced 2017-03-21 18:14 UTC by Report Bug Copy Issue Report It seems like `new static()` of type `this<Amarkal\Taxonomy\Form>` is incompatible with the declared type `object<Amarkal\Taxonomy\Singleton>` of property `$instance`. Our type inference engine has found an assignment to a property that is incompatible with the declared type of that property. Either this assignment is in error or the assigned type should be added to the documentation/type hint for that property.. Loading history...
30		}
31		return static::$instance;
		0 ignored issues – show Bug introduced 2017-03-21 18:14 UTC by Report Bug Copy Issue Report Since `$instance` is declared private, accessing it with `static` will lead to errors in possible sub-classes; consider using `self`, or increasing the visibility of `$instance` to at least protected. Let’s assume you have a class which uses late-static binding: class YourClass { private static $someVariable; public static function getSomeVariable() { return static::$someVariable; } } The code above will run fine in your PHP runtime. However, if you now create a sub-class and call the `getSomeVariable()` on that sub-class, you will receive a runtime error: class YourSubClass extends YourClass { } YourSubClass::getSomeVariable(); // Will cause an access error. In the case above, it makes sense to update `SomeClass` to use `self` instead: class SomeClass { private static $someVariable; public static function getSomeVariable() { return self::$someVariable; // self works fine with private. } } Loading history... Bug Compatibility introduced 2017-03-21 18:14 UTC by Report Bug Copy Issue Report The expression `static::$instance;` of type `Amarkal\Taxonomy\Form\|Amarkal\Taxonomy\Singleton` adds the type `Amarkal\Taxonomy\Form` to the return on line 31 which is incompatible with the return type documented by `Amarkal\Taxonomy\Form::get_instance` of type `Amarkal\Taxonomy\Singleton`. Loading history...
32		}
33
34		/**
35		* Add a form field to both the add & edit forms for a given taxonomy.
36		*
37		* @param string $taxonomy_name
38		* @param string $field_name
39		* @param array $field_props
40		* @throws \RuntimeException if duplicate names are registered under the same taxonomy
41		*/
42		public function add_field( $taxonomy_name, $field_name, $field_props )
43		{
44		if( !isset($this->fields[$taxonomy_name]) )
45		{
46		// Add fields to taxonomy add and edit forms
47		add_action( "{$taxonomy_name}_add_form_fields", array($this, 'render_add_form') );
48		add_action( "{$taxonomy_name}_edit_form_fields", array($this, 'render_edit_form') );
49
50		// Save the data from taxonomy add and edit forms
51		add_action( "create_{$taxonomy_name}", array($this, 'update_term') );
52		add_action( "edited_{$taxonomy_name}", array($this, 'update_term') );
53
54		// Modify the taxonomy term table
55		add_filter( "manage_edit-{$taxonomy_name}_columns", array($this, 'modify_table_columns') );
56		add_filter( "manage_{$taxonomy_name}_custom_column", array($this, 'modify_table_content'), 10, 3 );
57		add_filter( "manage_edit-{$taxonomy_name}_sortable_columns", array($this, 'modify_table_sortable_columns') );
58		add_filter( 'terms_clauses', array($this, 'sort_custom_column'), 10, 3 );
59
60		$this->fields[$taxonomy_name] = array();
61		}
62
63		if( !isset($this->fields[$taxonomy_name][$field_name]))
64		{
65		$this->fields[$taxonomy_name][$field_name] = array_merge( $this->default_props(), $field_props );
66		}
67		else throw new \RuntimeException("A field named '$field_name' has already been registered in '$taxonomy_name'");
68		}
69
70		/**
71		* Render the 'edit term' form for a given taxonomy
72		*
73		* @param object $term Taxonomy term
74		*/
75		public function render_edit_form( $term )
76		{
77		$fields = $this->fields[$term->taxonomy];
78
79		foreach( $fields as $name => $props )
80		{
81		$props['name'] = $name;
82		$props['term_id'] = $term->term_id;
83		$field = new EditField($props);
84		echo $field->render();
85		}
86		}
87
88		/**
89		* Render the 'add new term' form for a given taxonomy
90		*
91		* @param string $taxonomy Taxonomy name
92		*/
93		public function render_add_form( $taxonomy )
94		{
95		$fields = $this->fields[$taxonomy];
96
97		foreach( $fields as $name => $props )
98		{
99		$props['name'] = $name;
100		$field = new AddField($props);
101		echo $field->render();
102		}
103		}
104
105		/**
106		* Update the meta values for a given term. Called once one of the add/edit
107		* forms is saved.
108		*
109		* @param type $term_id
110		*/
111		function update_term( $term_id )
		0 ignored issues – show Best Practice introduced 2017-03-21 18:14 UTC by Report Bug Copy Issue Report It is generally recommended to explicitly declare the visibility for methods. Adding explicit visibility (`private`, `protected`, or `public`) is generally recommend to communicate to other developers how, and from where this method is intended to be used. Loading history... Coding Style introduced 2017-03-21 18:14 UTC by Report Bug Copy Issue Report `update_term` uses the super-global variable `$_POST` which is generally not recommended. Instead of super-globals, we recommend to explicitly inject the dependencies of your class. This makes your code less dependent on global state and it becomes generally more testable: // 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); } } Loading history...
112		{
113		$term = \get_term( $term_id );
114
115		foreach( $this->fields[$term->taxonomy] as $name => $props )
116		{
117		if( isset($_POST[$name]) )
118		{
119		update_term_meta($term_id, $name, filter_input(INPUT_POST, $name));
120		}
121		}
122		}
123
124		/**
125		* Add additional columns to the term table.
126		*
127		* @param array $columns
128		* @return array
129		*/
130	View Code Duplication	function modify_table_columns( $columns )
		0 ignored issues – show Best Practice introduced 2017-03-22 05:04 UTC by Report Bug Copy Issue Report It is generally recommended to explicitly declare the visibility for methods. Adding explicit visibility (`private`, `protected`, or `public`) is generally recommend to communicate to other developers how, and from where this method is intended to be used. Loading history... Duplication introduced 2017-03-22 05:04 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
131		{
132		foreach( $this->fields as $fields )
133		{
134		foreach( $fields as $name => $props )
135		{
136		if( $props['table']['show'] )
137		{
138		$columns[$name] = $props['label'];
139		}
140		}
141		}
142		return $columns;
143		}
144
145		/**
146		* Retrieve the data for a given column in the term table.
147		*
148		* @see https://developer.wordpress.org/reference/hooks/manage_this-screen-taxonomy_custom_column/
149		*
150		* @param type $content
151		* @param type $column_name
152		* @param type $term_id
153		* @return type
154		*/
155		function modify_table_content( $content, $column_name, $term_id )
		0 ignored issues – show Best Practice introduced 2017-03-22 05:04 UTC by Report Bug Copy Issue Report It is generally recommended to explicitly declare the visibility for methods. Adding explicit visibility (`private`, `protected`, or `public`) is generally recommend to communicate to other developers how, and from where this method is intended to be used. Loading history...
156		{
157		$term = \get_term($term_id);
158		foreach( $this->fields as $taxonomy => $fields )
159		{
160		foreach( $fields as $name => $props )
161		{
162		if( $props['table']['show'] &&
163		$term->taxonomy === $taxonomy &&
164		$name === $column_name
165		) {
166		$content = \get_term_meta($term_id, $name, true);
167		}
168		}
169		}
170		return $content;
171		}
172
173		/**
174		* Make custom table columns sortable.
175		*
176		* @param array $columns
177		* @return string
178		*/
179	View Code Duplication	function modify_table_sortable_columns( $columns )
		0 ignored issues – show Best Practice introduced 2017-03-22 05:04 UTC by Report Bug Copy Issue Report It is generally recommended to explicitly declare the visibility for methods. Adding explicit visibility (`private`, `protected`, or `public`) is generally recommend to communicate to other developers how, and from where this method is intended to be used. Loading history... Duplication introduced 2017-03-22 05:04 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
180		{
181		foreach( $this->fields as $taxonomy => $fields )
182		{
183		foreach( $fields as $name => $props )
184		{
185		if( $props['table']['show'] &&
186		$props['table']['sortable']
187		) {
188		$columns[$name] = $name;
189		}
190		}
191		}
192		return $columns;
193		}
194
195		/**
196		* Modify terms_clauses to allow sorting custom WordPress Admin Table Columns by a custom Taxonomy Term meta
197		*
198		* @see https://developer.wordpress.org/reference/hooks/terms_clauses/
199		*
200		* @global type $wpdb
201		* @param type $clauses
202		* @param type $taxonomies
203		* @param type $args
204		* @return string
205		*/
206		function sort_custom_column( $clauses, $taxonomies, $args )
		0 ignored issues – show Best Practice introduced 2017-03-22 05:04 UTC by Report Bug Copy Issue Report It is generally recommended to explicitly declare the visibility for methods. Adding explicit visibility (`private`, `protected`, or `public`) is generally recommend to communicate to other developers how, and from where this method is intended to be used. Loading history...
207		{
208		foreach( $this->fields as $taxonomy => $fields )
209		{
210		// if( in_array($taxonomy, $args['taxonomy']) && 'icon' === $args['orderby'])
		0 ignored issues – show Unused Code Comprehensibility introduced 2017-03-22 05:04 UTC by Report Bug Copy Issue Report `66%` of this comment could be valid code. Did you maybe forget this after debugging? Sometimes obsolete code just ends up commented out instead of removed. In this case it is better to remove the code once you have checked you do not need it. The code might also have been commented out for debugging purposes. In this case it is vital that someone uncomments it again or your project may behave in very unexpected ways in production. This check looks for comments that seem to be mostly valid code and reports them. Loading history...
211		foreach( $fields as $name => $props )
212		{
213		if( in_array($taxonomy, $args['taxonomy']) &&
214		$props['table']['show'] &&
215		$props['table']['sortable'] &&
216		$name === $args['orderby']
217		)
218		{
219		$this->modify_term_clauses( $clauses, $taxonomy, $name );
220		}
221		}
222		}
223		return $clauses;
224		}
225
226		/**
227		* Modify the orderby clauses for a given taxonomy
228		*
229		* @param array $clauses
230		* @param string $taxonomy
231		* @param string $termmeta
232		*/
233		function modify_term_clauses( &$clauses, $taxonomy, $termmeta )
		0 ignored issues – show Best Practice introduced 2017-03-22 05:04 UTC by Report Bug Copy Issue Report It is generally recommended to explicitly declare the visibility for methods. Adding explicit visibility (`private`, `protected`, or `public`) is generally recommend to communicate to other developers how, and from where this method is intended to be used. Loading history...
234		{
235		global $wpdb;
		0 ignored issues – show Compatibility Best Practice introduced 2017-03-22 05:04 UTC by Report Bug Copy Issue Report Use of `global` functionality is not recommended; it makes your code harder to test, and less reusable. Instead of relying on `global` state, we recommend one of these alternatives: 1. Pass all data via parameters function myFunction($a, $b) { // Do something } 2. Create a class that maintains your state class MyClass { private $a; private $b; public function __construct($a, $b) { $this->a = $a; $this->b = $b; } public function myFunction() { // Do something } } Loading history...
236		// tt refers to the $wpdb->term_taxonomy table
237		$clauses['join'] .= " LEFT JOIN {$wpdb->termmeta} AS tm ON t.term_id = tm.term_id";
238		$clauses['where'] = "tt.taxonomy = '{$taxonomy}' AND (tm.meta_key = '{$termmeta}' OR tm.meta_key IS NULL)";
239		$clauses['orderby'] = "ORDER BY tm.meta_value";
240		}
241
242		/**
243		* The default form field properties. This is merged with the user given
244		* properties. When the component is rendered, this will be merged with the
245		* component's properties as well.
246		*
247		* @return array
248		*/
249		private function default_props()
250		{
251		return array(
252		'type' => null,
253		'label' => null,
254		'description' => null,
255		'table' => array(
256		'show' => false,
257		'sortable' => false
258		)
259		);
260		}
261		}

amarkal / amarkal-taxonomy

Push — master ( 3e5a13...3a93f1 )

Form::add_field() B

Complexity

Size

Duplication

Importance

1. Pass all data via parameters

2. Create a class that maintains your state

Duplication Side-by-Side

Filter issues like