WikibaseQuality\ConstraintReport\ConstraintCheck\Checker\AllowedUnitsChecker

Complexity

Total Complexity

18

Size/Duplication

Total Lines	167
Duplicated Lines	30.54 %

Coupling/Cohesion

Components	1
Dependencies	8

Importance

Changes

0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	7	1
A	getSupportedContextTypes()	0	7	1
A	getDefaultContextTypes()	0	7	1
C	checkConstraint()	16	50	8
A	checkUnitless()	9	18	2
A	standardize()	12	12	3
A	checkConstraintParameters()	14	14	2

<?php

namespace WikibaseQuality\ConstraintReport\ConstraintCheck\Checker;

use DataValues\UnboundedQuantityValue;
use Wikibase\DataModel\Entity\ItemId;
use Wikibase\DataModel\Snak\PropertyValueSnak;
use Wikibase\Lib\Units\UnitConverter;
use WikibaseQuality\ConstraintReport\Constraint;
use WikibaseQuality\ConstraintReport\ConstraintCheck\ConstraintChecker;
use WikibaseQuality\ConstraintReport\ConstraintCheck\Context\Context;
use WikibaseQuality\ConstraintReport\ConstraintCheck\Helper\ConstraintParameterException;
use WikibaseQuality\ConstraintReport\ConstraintCheck\Helper\ConstraintParameterParser;
use WikibaseQuality\ConstraintReport\ConstraintCheck\Helper\UnitsParameter;
use WikibaseQuality\ConstraintReport\ConstraintCheck\Message\ViolationMessage;
use WikibaseQuality\ConstraintReport\ConstraintCheck\Result\CheckResult;
use WikibaseQuality\ConstraintReport\Role;

/**
 * @author Lucas Werkmeister
 * @license GPL-2.0-or-later
 */
class AllowedUnitsChecker implements ConstraintChecker {

	/**
	 * @var ConstraintParameterParser
	 */
	private $constraintParameterParser;

	/**
	 * @var UnitConverter|null
	 */
	private $unitConverter;

	/**
	 * @param ConstraintParameterParser $constraintParameterParser
	 * @param UnitConverter|null $unitConverter
	 */
	public function __construct(
		ConstraintParameterParser $constraintParameterParser,
		UnitConverter $unitConverter = null
	) {
		$this->constraintParameterParser = $constraintParameterParser;
		$this->unitConverter = $unitConverter;
	}

	/**
	 * @codeCoverageIgnore This method is purely declarative.
	 */
	public function getSupportedContextTypes() {
		return [
			Context::TYPE_STATEMENT => CheckResult::STATUS_COMPLIANCE,
			Context::TYPE_QUALIFIER => CheckResult::STATUS_COMPLIANCE,
			Context::TYPE_REFERENCE => CheckResult::STATUS_COMPLIANCE,
		];
	}

	/**
	 * @codeCoverageIgnore This method is purely declarative.
	 */
	public function getDefaultContextTypes() {
		return [
			Context::TYPE_STATEMENT,
			Context::TYPE_QUALIFIER,
			Context::TYPE_REFERENCE,
		];
	}

	/**
	 * Checks an “allowed units” constraint.
	 *
	 * @param Context $context
	 * @param Constraint $constraint
	 *
	 * @throws ConstraintParameterException
	 * @return CheckResult
	 */
	public function checkConstraint( Context $context, Constraint $constraint ) {
		$parameters = [];
		$constraintParameters = $constraint->getConstraintParameters();
		$unitsParameter = $this->constraintParameterParser
			->parseUnitsParameter(
				$constraintParameters,
				$constraint->getConstraintTypeItemId()
			);

		$snak = $context->getSnak();
		if ( !$snak instanceof PropertyValueSnak ) {
			// nothing to check
			return new CheckResult( $context, $constraint, $parameters, CheckResult::STATUS_COMPLIANCE );
		}

		$dataValue = $snak->getDataValue();
		if ( !$dataValue instanceof UnboundedQuantityValue ) {

The class DataValues\UnboundedQuantityValue does not exist. Did you forget a USE statement, or did you not list all dependencies?

This code seems to be duplicated across your project.

			$message = ( new ViolationMessage( 'wbqc-violation-message-value-needed-of-type' ) )
				->withEntityId( new ItemId( $constraint->getConstraintTypeItemId() ), Role::CONSTRAINT_TYPE_ITEM )
				->withDataValueType( 'quantity' );
			return new CheckResult( $context, $constraint, $parameters, CheckResult::STATUS_VIOLATION, $message );
		}

		if ( $dataValue->getUnit() === '1' ) {
			return $this->checkUnitless( $context, $constraint, $unitsParameter, $snak );
		}

		$status = CheckResult::STATUS_VIOLATION;
		$actualUnit = $this->standardize( $dataValue )->getUnit();
		foreach ( $unitsParameter->getUnitQuantities() as $unitQuantity ) {
			$allowedUnit = $this->standardize( $unitQuantity )->getUnit();
			if ( $actualUnit === $allowedUnit ) {
				$status = CheckResult::STATUS_COMPLIANCE;
				break;
			}
		}

		if ( $status === CheckResult::STATUS_VIOLATION ) {

This code seems to be duplicated across your project.

			$messageKey = $unitsParameter->getUnitlessAllowed() ?
				'wbqc-violation-message-units-or-none' :
				'wbqc-violation-message-units';
			$message = ( new ViolationMessage( $messageKey ) )
				->withEntityId( $snak->getPropertyId() )
				->withEntityIdList( $unitsParameter->getUnitItemIds() );
		} else {
			$message = null;
		}

		return new CheckResult( $context, $constraint, $parameters, $status, $message );
	}

	/**
	 * @param Context $context
	 * @param Constraint $constraint
	 * @param UnitsParameter $unitsParameter
	 * @param PropertyValueSnak $snak
	 * @return CheckResult
	 */
	private function checkUnitless(
		Context $context,
		Constraint $constraint,
		UnitsParameter $unitsParameter,
		PropertyValueSnak $snak
	) {
		if ( $unitsParameter->getUnitlessAllowed() ) {

This code seems to be duplicated across your project.

			$message = null;
			$status = CheckResult::STATUS_COMPLIANCE;
		} else {
			$message = ( new ViolationMessage( 'wbqc-violation-message-units' ) )
				->withEntityId( $snak->getPropertyId() )
				->withEntityIdList( $unitsParameter->getUnitItemIds() );
			$status = CheckResult::STATUS_VIOLATION;
		}

		return new CheckResult( $context, $constraint, [], $status, $message );
	}

	/**
	 * Convert $value to standard units.
	 *
	 * @param UnboundedQuantityValue $value
	 * @return UnboundedQuantityValue
	 */
	private function standardize( UnboundedQuantityValue $value ) {

This method seems to be duplicated in your project.

		if ( $this->unitConverter === null ) {
			return $value;
		}

		$standard = $this->unitConverter->toStandardUnits( $value );
		if ( $standard !== null ) {
			return $standard;
		} else {
			return $value;
		}
	}

	public function checkConstraintParameters( Constraint $constraint ) {

This method seems to be duplicated in your project.

		$constraintParameters = $constraint->getConstraintParameters();
		$exceptions = [];
		try {
			$this->constraintParameterParser->parseItemsParameter(
				$constraintParameters,
				$constraint->getConstraintTypeItemId(),
				true
			);
		} catch ( ConstraintParameterException $e ) {
			$exceptions[] = $e;
		}
		return $exceptions;
	}

}