SRFOutline::handleParameters() - Code Metrics - Inspection of "Add `template` to outline format, refs 88" - SemanticMediaWiki/SemanticResultFormats - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — outline ( 46d920 )

by mw

created 2019-01-12 01:25 UTC

SRFOutline::handleParameters() A

↳ Parent: Project

Complexity

Conditions	1
Paths	1

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	2

Importance

Changes

Metric	Value
dl	0
loc	4
ccs	0
cts	4
cp	0
rs	10
c	0
b	0
f	0
cc	1
nc	1
nop	2
crap	2

<?php

use SRF\Outline\TemplateBuilder;

/**
 * A class to print query results in an outline format, along with some
 * helper classes to handle the aggregation
 */

/**
 * Represents a single item, or page, in the outline - contains both the
 * SMWResultArray and an array of some of its values, for easier aggregation
 */
class SRFOutlineItem {

	var $mRow;
	var $mVals;

	function __construct( $row ) {

		$this->mRow = $row;
		$this->mVals = [];
	}

	function addFieldValue( $field_name, $field_val ) {

		if ( array_key_exists( $field_name, $this->mVals ) ) {
			$this->mVals[$field_name][] = $field_val;
		} else {
			$this->mVals[$field_name] = [ $field_val ];
		}
	}

	function getFieldValues( $field_name ) {

		if ( array_key_exists( $field_name, $this->mVals ) ) {
			return $this->mVals[$field_name];
		} else {
			return [ wfMessage( 'srf_outline_novalue' )->text() ];
		}
	}
}

/**
 * A tree structure for holding the outline data
 */
class SRFOutlineTree {

	var $mTree;
	var $mUnsortedItems;
	var $itemCount = 0;
	var $leafCount = 0;

	function __construct( $items = [] ) {

		$this->mTree = [];
		$this->mUnsortedItems = $items;
	}

	function addItem( $item ) {

		$this->mUnsortedItems[] = $item;
		$this->itemCount++;
	}

	function categorizeItem( $vals, $item ) {

		foreach ( $vals as $val ) {
			if ( array_key_exists( $val, $this->mTree ) ) {
				$this->mTree[$val]->mUnsortedItems[] = $item;
				$this->mTree[$val]->leafCount++;
			} else {
				$this->mTree[$val] = new SRFOutlineTree( [ $item ] );
				$this->mTree[$val]->leafCount++;
			}
		}
	}

	function addProperty( $property ) {

		if ( count( $this->mUnsortedItems ) > 0 ) {
			foreach ( $this->mUnsortedItems as $item ) {
				$cur_vals = $item->getFieldValues( $property );
				$this->categorizeItem( $cur_vals, $item );
			}
			$this->mUnsortedItems = null;
		} else {
			foreach ( $this->mTree as $i => $node ) {
				$this->mTree[$i]->addProperty( $property );
			}
		}
	}
}

class SRFOutline extends SMWResultPrinter {

	protected $mOutlineProperties = [];
	protected $mInnerFormat = '';

	public function getName() {
		return wfMessage( 'srf_printername_outline' )->text();
	}

	/**
	 * Code mostly copied from SMW's SMWListResultPrinter::getResultText()
	 */
	function printItem( $item ) {

		$first_col = true;
		$found_values = false; // has anything but the first column been printed?
		$result = "";
		foreach ( $item->mRow as $orig_ra ) {
			// handling is somewhat simpler for SMW 1.5+
			$realFunction = [ 'SMWQueryResult', 'getResults' ];
			if ( is_callable( $realFunction ) ) {
				// make a new copy of this, so that the call to
				// getNextText() will work again
				$ra = clone ( $orig_ra );
			} else {
				// make a new copy of this, so that the call to
				// getNextText() will work again
				$ra = new SMWResultArray( $orig_ra->getContent(), $orig_ra->getPrintRequest() );

			}
			$val = $ra->getPrintRequest()->getText( SMW_OUTPUT_WIKI, null );
			if ( in_array( $val, $this->params['outlineproperties'] ) ) {
				continue;
			}
			$first_value = true;
			while ( ( $text = $ra->getNextText( SMW_OUTPUT_WIKI, $this->mLinker ) ) !== false ) {
				if ( !$first_col && !$found_values ) { // first values after first column
					$result .= ' (';
					$found_values = true;
				} elseif ( $found_values || !$first_value ) {
					// any value after '(' or non-first values on first column
					$result .= ', ';
				}
				if ( $first_value ) { // first value in any column, print header
					$first_value = false;
					if ( $this->mShowHeaders && ( '' != $ra->getPrintRequest()->getLabel() ) ) {
						$result .= $ra->getPrintRequest()->getText( SMW_OUTPUT_WIKI, $this->mLinker ) . ' ';
					}
				}
				$result .= $text; // actual output value
			}
			$first_col = false;
		}
		if ( $found_values ) {
			$result .= ')';
		}
		return $result;
	}

	function printTree( $outline_tree, $level = 0 ) {

		$text = "";
		if ( !is_null( $outline_tree->mUnsortedItems ) ) {
			$text .= "<ul>\n";
			foreach ( $outline_tree->mUnsortedItems as $item ) {
				$text .= "<li>{$this->printItem($item)}</li>\n";
			}
			$text .= "</ul>\n";
		}
		if ( $level > 0 ) {
			$text .= "<ul>\n";
		}
		$num_levels = count( $this->params['outlineproperties'] );
		// set font size and weight depending on level we're at
		$font_level = $level;
		if ( $num_levels < 4 ) {
			$font_level += ( 4 - $num_levels );
		}
		if ( $font_level == 0 ) {
			$font_size = 'x-large';
		} elseif ( $font_level == 1 ) {
			$font_size = 'large';
		} elseif ( $font_level == 2 ) {
			$font_size = 'medium';
		} else {
			$font_size = 'small';
		}
		if ( $font_level == 3 ) {
			$font_weight = 'bold';
		} else {
			$font_weight = 'regular';
		}
		foreach ( $outline_tree->mTree as $key => $node ) {
			$text .= "<p style=\"font-size: $font_size; font-weight: $font_weight;\">$key</p>\n";
			$text .= $this->printTree( $node, $level + 1 );
		}
		if ( $level > 0 ) {
			$text .= "</ul>\n";
		}
		return $text;
	}

	protected function getResultText( SMWQueryResult $res, $outputmode ) {
		$print_fields = [];
		foreach ( $res->getPrintRequests() as $pr ) {
			$field_name = $pr->getText( $outputmode, $this->mLinker );
			// only print it if it's not already part of the
			// outline
			if ( !in_array( $field_name, $this->params['outlineproperties'] ) ) {
				$print_fields[] = $field_name;
			}
		}

		// for each result row, create an array of the row itself
		// and all its sorted-on fields, and add it to the initial
		// 'tree'
		$outline_tree = new SRFOutlineTree();
		while ( $row = $res->getNext() ) {
			$item = new SRFOutlineItem( $row );
			foreach ( $row as $field ) {
				$field_name = $field->getPrintRequest()->getText( SMW_OUTPUT_HTML );
				if ( in_array( $field_name, $this->params['outlineproperties'] ) ) {
					while ( ( $object = $field->getNextDataValue() ) !== false ) {
						$field_val = $object->getLongWikiText( $this->mLinker );
						$item->addFieldValue( $field_name, $field_val );
					}
				}
			}
			$outline_tree->addItem( $item );
		}

		// now, cycle through the outline properties, creating the
		// tree
		foreach ( $this->params['outlineproperties'] as $outline_prop ) {
			$outline_tree->addProperty( $outline_prop );
		}

		if ( $this->params['template'] !== '' ) {
			$this->hasTemplates = true;
			$templateBuilder = new TemplateBuilder(
				$this->params
			);

			$templateBuilder->setLinker( $this->mLinker );
			$result = $templateBuilder->build( $outline_tree );
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
		} else {
			$result = $this->printTree( $outline_tree );
		}

		if ( $this->linkFurtherResults( $res ) ) {
			$link = $this->getFurtherResultsLink( $res, $outputmode );

			$result .= $link->getText( $outputmode, $this->mLinker ) . "\n";
		}

		return $result;
	}

	/**
	 * @see SMWResultPrinter::getParamDefinitions
	 *
	 * @since 1.8
	 *
	 * @param $definitions array of IParamDefinition
	 *
	 * @return array of IParamDefinition|array
	 */
	public function getParamDefinitions( array $definitions ) {
		$params = parent::getParamDefinitions( $definitions );

		$params['outlineproperties'] = [
			'islist' => true,
			'default' => [],
			'message' => 'srf_paramdesc_outlineproperties',
		];

		$params[] = [
			'name' => 'template',
			'message' => 'smw-paramdesc-template',
			'default' => '',
		];

		$params[] = [
			'name' => 'userparam',
			'message' => 'smw-paramdesc-userparam',
			'default' => '',
		];

		$params[] = [
			'name' => 'named args',
			'type' => 'boolean',
			'message' => 'smw-paramdesc-named_args',
			'default' => true,
		];

		return $params;
	}

}


1			<?php
2
3			use SRF\Outline\TemplateBuilder;
4
5			/**
6			* A class to print query results in an outline format, along with some
7			* helper classes to handle the aggregation
8			*/
9
10			/**
11			* Represents a single item, or page, in the outline - contains both the
12			* SMWResultArray and an array of some of its values, for easier aggregation
13			*/
14			class SRFOutlineItem {
15
16			var $mRow;
17			var $mVals;
18
19			function __construct( $row ) {
			0 ignored issues – show Best Practice introduced 2015-11-28 10:35 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... Comprehensibility Best Practice introduced 2015-11-28 10:35 UTC by Report Bug Copy Issue Report It is recommend to declare an explicit visibility for `__construct`. Generally, we recommend to declare visibility for all methods in your source code. This has the advantage of clearly communication to other developers, and also yourself, how this method should be consumed. If you are not sure which visibility to choose, it is a good idea to start with the most restrictive visibility, and then raise visibility as needed, i.e. start with `private`, and only raise it to `protected` if a sub-class needs to have access, or `public` if an external class needs access. Loading history...
20			$this->mRow = $row;
21			$this->mVals = [];
22			}
23
24			function addFieldValue( $field_name, $field_val ) {
			0 ignored issues – show Best Practice introduced 2015-11-28 10:35 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... Comprehensibility Best Practice introduced 2015-11-28 10:35 UTC by Report Bug Copy Issue Report It is recommend to declare an explicit visibility for `addFieldValue`. Generally, we recommend to declare visibility for all methods in your source code. This has the advantage of clearly communication to other developers, and also yourself, how this method should be consumed. If you are not sure which visibility to choose, it is a good idea to start with the most restrictive visibility, and then raise visibility as needed, i.e. start with `private`, and only raise it to `protected` if a sub-class needs to have access, or `public` if an external class needs access. Loading history...
25			if ( array_key_exists( $field_name, $this->mVals ) ) {
26			$this->mVals[$field_name][] = $field_val;
27			} else {
28			$this->mVals[$field_name] = [ $field_val ];
29			}
30			}
31
32			function getFieldValues( $field_name ) {
			0 ignored issues – show Best Practice introduced 2015-11-28 10:35 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... Comprehensibility Best Practice introduced 2015-11-28 10:35 UTC by Report Bug Copy Issue Report It is recommend to declare an explicit visibility for `getFieldValues`. Generally, we recommend to declare visibility for all methods in your source code. This has the advantage of clearly communication to other developers, and also yourself, how this method should be consumed. If you are not sure which visibility to choose, it is a good idea to start with the most restrictive visibility, and then raise visibility as needed, i.e. start with `private`, and only raise it to `protected` if a sub-class needs to have access, or `public` if an external class needs access. Loading history...
33			if ( array_key_exists( $field_name, $this->mVals ) ) {
34			return $this->mVals[$field_name];
35			} else {
36			return [ wfMessage( 'srf_outline_novalue' )->text() ];
37			}
38			}
39			}
40
41			/**
42			* A tree structure for holding the outline data
43			*/
44			class SRFOutlineTree {
45
46			var $mTree;
47			var $mUnsortedItems;
48			var $itemCount = 0;
49			var $leafCount = 0;
50
51			function __construct( $items = [] ) {
			0 ignored issues – show Best Practice introduced 2017-05-25 18:54 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... Comprehensibility Best Practice introduced 2017-05-25 18:54 UTC by Report Bug Copy Issue Report It is recommend to declare an explicit visibility for `__construct`. Generally, we recommend to declare visibility for all methods in your source code. This has the advantage of clearly communication to other developers, and also yourself, how this method should be consumed. If you are not sure which visibility to choose, it is a good idea to start with the most restrictive visibility, and then raise visibility as needed, i.e. start with `private`, and only raise it to `protected` if a sub-class needs to have access, or `public` if an external class needs access. Loading history...
52			$this->mTree = [];
53			$this->mUnsortedItems = $items;
54			}
55
56			function addItem( $item ) {
			0 ignored issues – show Best Practice introduced 2015-11-28 10:35 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... Comprehensibility Best Practice introduced 2015-11-28 10:35 UTC by Report Bug Copy Issue Report It is recommend to declare an explicit visibility for `addItem`. Generally, we recommend to declare visibility for all methods in your source code. This has the advantage of clearly communication to other developers, and also yourself, how this method should be consumed. If you are not sure which visibility to choose, it is a good idea to start with the most restrictive visibility, and then raise visibility as needed, i.e. start with `private`, and only raise it to `protected` if a sub-class needs to have access, or `public` if an external class needs access. Loading history...
57			$this->mUnsortedItems[] = $item;
58			$this->itemCount++;
59			}
60
61			function categorizeItem( $vals, $item ) {
			0 ignored issues – show Best Practice introduced 2015-11-28 10:35 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... Comprehensibility Best Practice introduced 2015-11-28 10:35 UTC by Report Bug Copy Issue Report It is recommend to declare an explicit visibility for `categorizeItem`. Generally, we recommend to declare visibility for all methods in your source code. This has the advantage of clearly communication to other developers, and also yourself, how this method should be consumed. If you are not sure which visibility to choose, it is a good idea to start with the most restrictive visibility, and then raise visibility as needed, i.e. start with `private`, and only raise it to `protected` if a sub-class needs to have access, or `public` if an external class needs access. Loading history...
62			foreach ( $vals as $val ) {
63			if ( array_key_exists( $val, $this->mTree ) ) {
64			$this->mTree[$val]->mUnsortedItems[] = $item;
65			$this->mTree[$val]->leafCount++;
66			} else {
67			$this->mTree[$val] = new SRFOutlineTree( [ $item ] );
68			$this->mTree[$val]->leafCount++;
69			}
70			}
71			}
72
73			function addProperty( $property ) {
			0 ignored issues – show Best Practice introduced 2015-11-28 10:35 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... Comprehensibility Best Practice introduced 2015-11-28 10:35 UTC by Report Bug Copy Issue Report It is recommend to declare an explicit visibility for `addProperty`. Generally, we recommend to declare visibility for all methods in your source code. This has the advantage of clearly communication to other developers, and also yourself, how this method should be consumed. If you are not sure which visibility to choose, it is a good idea to start with the most restrictive visibility, and then raise visibility as needed, i.e. start with `private`, and only raise it to `protected` if a sub-class needs to have access, or `public` if an external class needs access. Loading history...
74			if ( count( $this->mUnsortedItems ) > 0 ) {
75			foreach ( $this->mUnsortedItems as $item ) {
76			$cur_vals = $item->getFieldValues( $property );
77			$this->categorizeItem( $cur_vals, $item );
78			}
79			$this->mUnsortedItems = null;
80			} else {
81			foreach ( $this->mTree as $i => $node ) {
82			$this->mTree[$i]->addProperty( $property );
83			}
84			}
85			}
86			}
87
88			class SRFOutline extends SMWResultPrinter {
89
90			protected $mOutlineProperties = [];
91			protected $mInnerFormat = '';
92
93			public function getName() {
94			return wfMessage( 'srf_printername_outline' )->text();
95			}
96
97			/**
98			* Code mostly copied from SMW's SMWListResultPrinter::getResultText()
99			*/
100			function printItem( $item ) {
			0 ignored issues – show Best Practice introduced 2015-11-28 10:35 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... Comprehensibility Best Practice introduced 2015-11-28 10:35 UTC by Report Bug Copy Issue Report It is recommend to declare an explicit visibility for `printItem`. Generally, we recommend to declare visibility for all methods in your source code. This has the advantage of clearly communication to other developers, and also yourself, how this method should be consumed. If you are not sure which visibility to choose, it is a good idea to start with the most restrictive visibility, and then raise visibility as needed, i.e. start with `private`, and only raise it to `protected` if a sub-class needs to have access, or `public` if an external class needs access. Loading history...
101			$first_col = true;
102			$found_values = false; // has anything but the first column been printed?
103			$result = "";
104			foreach ( $item->mRow as $orig_ra ) {
105			// handling is somewhat simpler for SMW 1.5+
106			$realFunction = [ 'SMWQueryResult', 'getResults' ];
107			if ( is_callable( $realFunction ) ) {
108			// make a new copy of this, so that the call to
109			// getNextText() will work again
110			$ra = clone ( $orig_ra );
111			} else {
112			// make a new copy of this, so that the call to
113			// getNextText() will work again
114			$ra = new SMWResultArray( $orig_ra->getContent(), $orig_ra->getPrintRequest() );
			0 ignored issues – show Bug introduced 2015-11-28 10:35 UTC by Report Bug Copy Issue Report The call to `SMWResultArray::__construct()` misses a required argument `$store`. This check looks for function calls that miss required arguments. Loading history...
115			}
116			$val = $ra->getPrintRequest()->getText( SMW_OUTPUT_WIKI, null );
117			if ( in_array( $val, $this->params['outlineproperties'] ) ) {
118			continue;
119			}
120			$first_value = true;
121			while ( ( $text = $ra->getNextText( SMW_OUTPUT_WIKI, $this->mLinker ) ) !== false ) {
122			if ( !$first_col && !$found_values ) { // first values after first column
123			$result .= ' (';
124			$found_values = true;
125			} elseif ( $found_values \|\| !$first_value ) {
126			// any value after '(' or non-first values on first column
127			$result .= ', ';
128			}
129			if ( $first_value ) { // first value in any column, print header
130			$first_value = false;
131			if ( $this->mShowHeaders && ( '' != $ra->getPrintRequest()->getLabel() ) ) {
132			$result .= $ra->getPrintRequest()->getText( SMW_OUTPUT_WIKI, $this->mLinker ) . ' ';
133			}
134			}
135			$result .= $text; // actual output value
136			}
137			$first_col = false;
138			}
139			if ( $found_values ) {
140			$result .= ')';
141			}
142			return $result;
143			}
144
145			function printTree( $outline_tree, $level = 0 ) {
			0 ignored issues – show Best Practice introduced 2015-11-28 10:35 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... Comprehensibility Best Practice introduced 2015-11-28 10:35 UTC by Report Bug Copy Issue Report It is recommend to declare an explicit visibility for `printTree`. Generally, we recommend to declare visibility for all methods in your source code. This has the advantage of clearly communication to other developers, and also yourself, how this method should be consumed. If you are not sure which visibility to choose, it is a good idea to start with the most restrictive visibility, and then raise visibility as needed, i.e. start with `private`, and only raise it to `protected` if a sub-class needs to have access, or `public` if an external class needs access. Loading history...
146			$text = "";
147			if ( !is_null( $outline_tree->mUnsortedItems ) ) {
148			$text .= "<ul>\n";
149			foreach ( $outline_tree->mUnsortedItems as $item ) {
150			$text .= "<li>{$this->printItem($item)}</li>\n";
151			}
152			$text .= "</ul>\n";
153			}
154			if ( $level > 0 ) {
155			$text .= "<ul>\n";
156			}
157			$num_levels = count( $this->params['outlineproperties'] );
158			// set font size and weight depending on level we're at
159			$font_level = $level;
160			if ( $num_levels < 4 ) {
161			$font_level += ( 4 - $num_levels );
162			}
163			if ( $font_level == 0 ) {
164			$font_size = 'x-large';
165			} elseif ( $font_level == 1 ) {
166			$font_size = 'large';
167			} elseif ( $font_level == 2 ) {
168			$font_size = 'medium';
169			} else {
170			$font_size = 'small';
171			}
172			if ( $font_level == 3 ) {
173			$font_weight = 'bold';
174			} else {
175			$font_weight = 'regular';
176			}
177			foreach ( $outline_tree->mTree as $key => $node ) {
178			$text .= "<p style=\"font-size: $font_size; font-weight: $font_weight;\">$key</p>\n";
179			$text .= $this->printTree( $node, $level + 1 );
180			}
181			if ( $level > 0 ) {
182			$text .= "</ul>\n";
183			}
184			return $text;
185			}
186
187			protected function getResultText( SMWQueryResult $res, $outputmode ) {
188			$print_fields = [];
189			foreach ( $res->getPrintRequests() as $pr ) {
190			$field_name = $pr->getText( $outputmode, $this->mLinker );
191			// only print it if it's not already part of the
192			// outline
193			if ( !in_array( $field_name, $this->params['outlineproperties'] ) ) {
194			$print_fields[] = $field_name;
195			}
196			}
197
198			// for each result row, create an array of the row itself
199			// and all its sorted-on fields, and add it to the initial
200			// 'tree'
201			$outline_tree = new SRFOutlineTree();
202			while ( $row = $res->getNext() ) {
203			$item = new SRFOutlineItem( $row );
204			foreach ( $row as $field ) {
205			$field_name = $field->getPrintRequest()->getText( SMW_OUTPUT_HTML );
206			if ( in_array( $field_name, $this->params['outlineproperties'] ) ) {
207			while ( ( $object = $field->getNextDataValue() ) !== false ) {
208			$field_val = $object->getLongWikiText( $this->mLinker );
209			$item->addFieldValue( $field_name, $field_val );
210			}
211			}
212			}
213			$outline_tree->addItem( $item );
214			}
215
216			// now, cycle through the outline properties, creating the
217			// tree
218			foreach ( $this->params['outlineproperties'] as $outline_prop ) {
219			$outline_tree->addProperty( $outline_prop );
220			}
221
222			if ( $this->params['template'] !== '' ) {
223			$this->hasTemplates = true;
224			$templateBuilder = new TemplateBuilder(
225			$this->params
226			);
227
228			$templateBuilder->setLinker( $this->mLinker );
229			$result = $templateBuilder->build( $outline_tree );
			0 ignored issues – show Documentation introduced 2019-01-12 01:41 UTC by Report Bug Copy Issue Report `$outline_tree` is of type `object<SRFOutlineTree>`, but the function expects a `object<SRF\Outline\OutlineTree>`. It seems like the type of the argument is not accepted by the function/method which you are calling. In some cases, in particular if PHP’s automatic type-juggling kicks in this might be fine. In other cases, however this might be a bug. We suggest to add an explicit type cast like in the following example: function acceptsInteger($int) { } $x = '123'; // string "123" // Instead of acceptsInteger($x); // we recommend to use acceptsInteger((integer) $x); Loading history...
230			} else {
231			$result = $this->printTree( $outline_tree );
232			}
233
234			if ( $this->linkFurtherResults( $res ) ) {
235			$link = $this->getFurtherResultsLink( $res, $outputmode );
236
237			$result .= $link->getText( $outputmode, $this->mLinker ) . "\n";
238			}
239
240			return $result;
241			}
242
243			/**
244			* @see SMWResultPrinter::getParamDefinitions
245			*
246			* @since 1.8
247			*
248			* @param $definitions array of IParamDefinition
249			*
250			* @return array of IParamDefinition\|array
251			*/
252			public function getParamDefinitions( array $definitions ) {
253			$params = parent::getParamDefinitions( $definitions );
254
255			$params['outlineproperties'] = [
256			'islist' => true,
257			'default' => [],
258			'message' => 'srf_paramdesc_outlineproperties',
259			];
260
261			$params[] = [
262			'name' => 'template',
263			'message' => 'smw-paramdesc-template',
264			'default' => '',
265			];
266
267			$params[] = [
268			'name' => 'userparam',
269			'message' => 'smw-paramdesc-userparam',
270			'default' => '',
271			];
272
273			$params[] = [
274			'name' => 'named args',
275			'type' => 'boolean',
276			'message' => 'smw-paramdesc-named_args',
277			'default' => true,
278			];
279
280			return $params;
281			}
282
283			}
284

SemanticMediaWiki / SemanticResultFormats

Push — outline ( 46d920 )

SRFOutline::handleParameters() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like