MissingSubjectTripleNodeSimplifier::buildQueryForUnion() - Code Metrics - Inspection of "Add trace." - ProjetPP/PPP-Wikidata - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#123)

by Valentin

created 2016-04-01 14:08 UTC

buildQueryForUnion() B

↳ Parent: MissingSubjectTripleNodeSimplifier

Complexity

Conditions	5
Paths	9

Size

Total Lines	20
Code Lines	13

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	8
CRAP Score	5

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
c	1
b	0
f	0
dl	0
loc	20
ccs	8
cts	8
cp	1
rs	8.8571
cc	5
eloc	13
nc	9
nop	1
crap	5

<?php

namespace PPP\Wikidata\TreeSimplifier;

use Ask\Language\Description\Conjunction;
use Ask\Language\Description\Disjunction;
use Ask\Language\Description\SomeProperty;
use Ask\Language\Description\ValueDescription;
use Ask\Language\Option\QueryOptions;
use InvalidArgumentException;
use PPP\DataModel\AbstractNode;
use PPP\DataModel\IntersectionNode;
use PPP\DataModel\MissingNode;
use PPP\DataModel\ResourceListNode;
use PPP\DataModel\TripleNode;
use PPP\DataModel\UnionNode;
use PPP\Module\TreeSimplifier\NodeSimplifier;
use PPP\Module\TreeSimplifier\NodeSimplifierException;
use PPP\Module\TreeSimplifier\NodeSimplifierFactory;
use PPP\Wikidata\ValueParsers\ResourceListNodeParser;
use PPP\Wikidata\WikibaseResourceNode;
use Wikibase\DataModel\Entity\EntityIdValue;
use Wikibase\EntityStore\EntityStore;

/**
 * Simplifies a triple node when the subject is missing.
 *
 * @licence GPLv2+
 * @author Thomas Pellissier Tanon
 */
class MissingSubjectTripleNodeSimplifier implements NodeSimplifier {

	const QUERY_LIMIT = 50;

	/**
	 * @var NodeSimplifierFactory
	 */
	private $nodeSimplifierFactory;

	/**
	 * @var EntityStore
	 */
	private $entityStore;

	/**
	 * @var ResourceListNodeParser
	 */
	private $resourceListNodeParser;

	/**
	 * @param NodeSimplifierFactory $nodeSimplifierFactory
	 * @param EntityStore $entityStore
	 * @param ResourceListNodeParser $resourceListNodeParser
	 */
	public function __construct(NodeSimplifierFactory $nodeSimplifierFactory, EntityStore $entityStore, ResourceListNodeParser $resourceListNodeParser) {
		$this->nodeSimplifierFactory = $nodeSimplifierFactory;
		$this->entityStore = $entityStore;
		$this->resourceListNodeParser = $resourceListNodeParser;
	}

	/**
	 * @see AbstractNode::isSimplifierFor
	 */
	public function isSimplifierFor(AbstractNode $node) {
		return $this->isTripleWithMissingSubject($node) || $this->isTripleWithMissingSubjectOperator($node);
	}

	private function isTripleWithMissingSubject(AbstractNode $node) {
		return $node instanceof TripleNode &&
			$node->getSubject() instanceof MissingNode;
	}

	private function isTripleWithMissingSubjectOperator(AbstractNode $node) {
		if(!($node instanceof IntersectionNode || $node instanceof UnionNode)) {
			return false;
		}

		foreach($node->getOperands() as $operand) {
			if(!$this->isSimplifierFor($operand)) {
				return false;
			}
		}

		return true;
	}

	/**
	 * @see NodeSimplifier::doSimplification
	 */
	public function simplify(AbstractNode $node) {
		try {
			$query = $this->buildQueryForNode($node);
		} catch(EmptyQueryException $e) {
			return new ResourceListNode();
		}

		$entityIds = $this->entityStore->getItemIdForQueryLookup()->getItemIdsForQuery($query, new QueryOptions(self::QUERY_LIMIT, 0));

		return $this->formatQueryResult($entityIds);
	}

	private function buildQueryForNode(AbstractNode $node) {
		if($node instanceof UnionNode) {
			return $this->buildQueryForUnion($node);
		} else if($node instanceof IntersectionNode) {
			return $this->buildQueryForIntersection($node);
		} else if($node instanceof TripleNode) {
			return $this->buildQueryForTriple($node);
		} else {
			throw new InvalidArgumentException('Unsupported Node');
		}
	}

	private function buildQueryForUnion(UnionNode $unionNode) {
		$queries = array();

		foreach($unionNode->getOperands() as $operandNode) {
			try {
				$queries[] = $this->buildQueryForNode($operandNode);
			} catch(EmptyQueryException $e) {
				//May be ignored: we are in a union
			}
		}

		switch(count($queries)) {
			case 0:
				throw new EmptyQueryException();
			case 1:
				return reset($queries);
			default:
				return new Disjunction($queries);
		}
	}

	private function buildQueryForIntersection(IntersectionNode $intersectionNode) {
		$queries = array();

		foreach($intersectionNode->getOperands() as $operandNode) {
			$queries[] = $this->buildQueryForNode($operandNode);
		}

		switch(count($queries)) {
			case 1:
				return reset($queries);
			default:
				return new Conjunction($queries);
		}
	}

	private function buildQueryForTriple(TripleNode $triple) {
		if(!($triple->getSubject()->equals(new MissingNode()))) {
			throw new InvalidArgumentException('Triple whose subject is not missing given.');
		}

		$simplifier = $this->nodeSimplifierFactory->newNodeSimplifier();
		$predicate = $simplifier->simplify($triple->getPredicate());
		$object = $simplifier->simplify($triple->getObject());
		if(!($predicate instanceof ResourceListNode && $object instanceof ResourceListNode)) {
			throw new NodeSimplifierException('Invalid triple');
		}

		$propertyNodes = $this->resourceListNodeParser->parse($predicate, 'wikibase-property');
		$queryParameters = array();

		foreach($this->bagsPropertiesPerType($propertyNodes) as $objectType => $propertyNodes) {
			$objectNodes = $this->resourceListNodeParser->parse($object, $objectType);

			foreach($propertyNodes as $propertyNode) {
				try {
					$queryParameters[] = $this->buildQueryForProperty($propertyNode, $objectNodes);
				} catch(EmptyQueryException $e) {
					//May be ignored: we are in a union
				}
			}
		}

		switch(count($queryParameters)) {
			case 0:
				throw new EmptyQueryException();
			case 1:
				return reset($queryParameters);
			default:
				return new Disjunction($queryParameters);
		}
	}

	private function bagsPropertiesPerType($propertyNodes) {
		$propertyNodesPerType = array();

		/** @var WikibaseResourceNode $propertyNode */
		foreach($propertyNodes as $propertyNode) {
			$objectType = $this->entityStore->getPropertyLookup()->getPropertyForId(
				$propertyNode->getDataValue()->getEntityId()
			)->getDataTypeId();
			$propertyNodesPerType[$objectType][] = $propertyNode;
		}

		return $propertyNodesPerType;
	}

	private function buildQueryForProperty(WikibaseResourceNode $predicate, ResourceListNode $objectList) {
		return new SomeProperty(
			new EntityIdValue($predicate->getDataValue()->getEntityId()),
interface User
{
    /** @return string */
    public function getPassword();
}

class MyUser implements User
{
    public function getPassword()
    {
        // return something
    }

    public function getDisplayName()
    {
        // return some name.
    }
}

class AuthSystem
{
    public function authenticate(User $user)
    {
        $this->logger->info(sprintf('Authenticating %s.', $user->getDisplayName()));
        // do something.
    }
}
			$this->buildValueDescriptionsForObjects($objectList)
		);
	}

	private function buildValueDescriptionsForObjects(ResourceListNode $objectList) {
		$valueDescriptions = array();

		/** @var WikibaseResourceNode $object */
		foreach($objectList as $object) {
			$valueDescriptions[] = new ValueDescription($object->getDataValue());
		}

		switch(count($valueDescriptions)) {
			case 0:
				throw new EmptyQueryException();
			case 1:
				return reset($valueDescriptions);
			default:
				return new Disjunction($valueDescriptions);
		}
	}

	private function formatQueryResult(array $subjectIds) {
		$nodes = array();

		foreach($subjectIds as $subjectId) {
			$nodes[] = new WikibaseResourceNode('', new EntityIdValue($subjectId));
		}

		return new ResourceListNode($nodes);
	}
}


1		<?php
2
3		namespace PPP\Wikidata\TreeSimplifier;
4
5		use Ask\Language\Description\Conjunction;
6		use Ask\Language\Description\Disjunction;
7		use Ask\Language\Description\SomeProperty;
8		use Ask\Language\Description\ValueDescription;
9		use Ask\Language\Option\QueryOptions;
10		use InvalidArgumentException;
11		use PPP\DataModel\AbstractNode;
12		use PPP\DataModel\IntersectionNode;
13		use PPP\DataModel\MissingNode;
14		use PPP\DataModel\ResourceListNode;
15		use PPP\DataModel\TripleNode;
16		use PPP\DataModel\UnionNode;
17		use PPP\Module\TreeSimplifier\NodeSimplifier;
18		use PPP\Module\TreeSimplifier\NodeSimplifierException;
19		use PPP\Module\TreeSimplifier\NodeSimplifierFactory;
20		use PPP\Wikidata\ValueParsers\ResourceListNodeParser;
21		use PPP\Wikidata\WikibaseResourceNode;
22		use Wikibase\DataModel\Entity\EntityIdValue;
23		use Wikibase\EntityStore\EntityStore;
24
25		/**
26		* Simplifies a triple node when the subject is missing.
27		*
28		* @licence GPLv2+
29		* @author Thomas Pellissier Tanon
30		*/
31		class MissingSubjectTripleNodeSimplifier implements NodeSimplifier {
32
33		const QUERY_LIMIT = 50;
34
35		/**
36		* @var NodeSimplifierFactory
37		*/
38		private $nodeSimplifierFactory;
39
40		/**
41		* @var EntityStore
42		*/
43		private $entityStore;
44
45		/**
46		* @var ResourceListNodeParser
47		*/
48		private $resourceListNodeParser;
49
50		/**
51		* @param NodeSimplifierFactory $nodeSimplifierFactory
52		* @param EntityStore $entityStore
53		* @param ResourceListNodeParser $resourceListNodeParser
54		*/
55	22	public function __construct(NodeSimplifierFactory $nodeSimplifierFactory, EntityStore $entityStore, ResourceListNodeParser $resourceListNodeParser) {
56	22	$this->nodeSimplifierFactory = $nodeSimplifierFactory;
57	22	$this->entityStore = $entityStore;
58	22	$this->resourceListNodeParser = $resourceListNodeParser;
59		}
60
61		/**
62		* @see AbstractNode::isSimplifierFor
63		*/
64	5	public function isSimplifierFor(AbstractNode $node) {
65		return $this->isTripleWithMissingSubject($node) \|\| $this->isTripleWithMissingSubjectOperator($node);
66	5	}
67
68	5	private function isTripleWithMissingSubject(AbstractNode $node) {
69	5	return $node instanceof TripleNode &&
70	1	$node->getSubject() instanceof MissingNode;
71	5	}
72
73	4	private function isTripleWithMissingSubjectOperator(AbstractNode $node) {
74	3	if(!($node instanceof IntersectionNode \|\| $node instanceof UnionNode)) {
75	4	return false;
76		}
77
78		foreach($node->getOperands() as $operand) {
79		if(!$this->isSimplifierFor($operand)) {
80		return false;
81		}
82		}
83
84		return true;
85	3	}
86
87		/**
88		* @see NodeSimplifier::doSimplification
89		*/
90	14	public function simplify(AbstractNode $node) {
91		try {
92	8	$query = $this->buildQueryForNode($node);
93		} catch(EmptyQueryException $e) {
94		return new ResourceListNode();
95	10	}
96
97		$entityIds = $this->entityStore->getItemIdForQueryLookup()->getItemIdsForQuery($query, new QueryOptions(self::QUERY_LIMIT, 0));
98
99		return $this->formatQueryResult($entityIds);
100	14	}
101
102	12	private function buildQueryForNode(AbstractNode $node) {
103	9	if($node instanceof UnionNode) {
104	3	return $this->buildQueryForUnion($node);
105	10	} else if($node instanceof IntersectionNode) {
106	1	return $this->buildQueryForIntersection($node);
107	12	} else if($node instanceof TripleNode) {
108	6	return $this->buildQueryForTriple($node);
109		} else {
110		throw new InvalidArgumentException('Unsupported Node');
111		}
112	9	}
113
114	5	private function buildQueryForUnion(UnionNode $unionNode) {
115	5	$queries = array();
116
117	5	foreach($unionNode->getOperands() as $operandNode) {
118		try {
119	2	$queries[] = $this->buildQueryForNode($operandNode);
120		} catch(EmptyQueryException $e) {
121		//May be ignored: we are in a union
122	2	}
123	2	}
124
125	4	switch(count($queries)) {
126		case 0:
127		throw new EmptyQueryException();
128		case 1:
129		return reset($queries);
130		default:
131		return new Disjunction($queries);
132		}
133	4	}
134
135	3	private function buildQueryForIntersection(IntersectionNode $intersectionNode) {
136	3	$queries = array();
137
138	3	foreach($intersectionNode->getOperands() as $operandNode) {
139	1	$queries[] = $this->buildQueryForNode($operandNode);
140	1	}
141
142	2	switch(count($queries)) {
143		case 1:
144		return reset($queries);
145		default:
146		return new Conjunction($queries);
147		}
148	2	}
149
150	11	private function buildQueryForTriple(TripleNode $triple) {
151		if(!($triple->getSubject()->equals(new MissingNode()))) {
152		throw new InvalidArgumentException('Triple whose subject is not missing given.');
153		}
154
155		$simplifier = $this->nodeSimplifierFactory->newNodeSimplifier();
156		$predicate = $simplifier->simplify($triple->getPredicate());
157		$object = $simplifier->simplify($triple->getObject());
158	8	if(!($predicate instanceof ResourceListNode && $object instanceof ResourceListNode)) {
159		throw new NodeSimplifierException('Invalid triple');
160		}
161
162		$propertyNodes = $this->resourceListNodeParser->parse($predicate, 'wikibase-property');
163	8	$queryParameters = array();
164
165	8	foreach($this->bagsPropertiesPerType($propertyNodes) as $objectType => $propertyNodes) {
166		$objectNodes = $this->resourceListNodeParser->parse($object, $objectType);
167
168		foreach($propertyNodes as $propertyNode) {
169		try {
170	1	$queryParameters[] = $this->buildQueryForProperty($propertyNode, $objectNodes);
171		} catch(EmptyQueryException $e) {
172		//May be ignored: we are in a union
173	4	}
174		}
175	2	}
176
177	8	switch(count($queryParameters)) {
178		case 0:
179		throw new EmptyQueryException();
180		case 1:
181		return reset($queryParameters);
182		default:
183		return new Disjunction($queryParameters);
184		}
185	11	}
186
187	8	private function bagsPropertiesPerType($propertyNodes) {
188	8	$propertyNodesPerType = array();
189
190		/** @var WikibaseResourceNode $propertyNode */
191		foreach($propertyNodes as $propertyNode) {
192	4	$objectType = $this->entityStore->getPropertyLookup()->getPropertyForId(
193		$propertyNode->getDataValue()->getEntityId()
194		)->getDataTypeId();
195	4	$propertyNodesPerType[$objectType][] = $propertyNode;
196	2	}
197
198	8	return $propertyNodesPerType;
199		}
200
201	4	private function buildQueryForProperty(WikibaseResourceNode $predicate, ResourceListNode $objectList) {
202		return new SomeProperty(
203		new EntityIdValue($predicate->getDataValue()->getEntityId()),
		0 ignored issues – show Bug introduced 2016-01-11 15:51 UTC by Report Bug Copy Issue Report It seems like you code against a concrete implementation and not the interface `DataValues\DataValue` as the method `getEntityId()` does only exist in the following implementations of said interface: `Wikibase\DataModel\Entity\EntityIdValue`. Let’s take a look at an example: interface User { /** @return string / public function getPassword(); } class MyUser implements User { public function getPassword() { // return something } public function getDisplayName() { // return some name. } } class AuthSystem { public function authenticate(User $user) { $this->logger->info(sprintf('Authenticating %s.', $user->getDisplayName())); // do something. } } In the above example, the authenticate() method works fine as long as you just pass instances of MyUser. However, if you now also want to pass a different implementation of User which does not have a getDisplayName() method, the code will break. Available Fixes Change the type-hint for the parameter: class AuthSystem { public function authenticate(MyUser $user) { / ... / } } Add an additional type-check: class AuthSystem { public function authenticate(User $user) { if ($user instanceof MyUser) { $this->logger->info(/* ... /); } // or alternatively if ( ! $user instanceof MyUser) { throw new \LogicException( '$user must be an instance of MyUser, ' .'other instances are not supported.' ); } } } Note:* PHP Analyzer uses reverse abstract interpretation to narrow down the types inside the if block in such a case. Add the method to the interface: interface User { /** @return string / public function getPassword(); /* @return string */ public function getDisplayName(); } Loading history...
204	4	$this->buildValueDescriptionsForObjects($objectList)
205		);
206	4	}
207
208	4	private function buildValueDescriptionsForObjects(ResourceListNode $objectList) {
209	4	$valueDescriptions = array();
210
211		/** @var WikibaseResourceNode $object */
212		foreach($objectList as $object) {
213		$valueDescriptions[] = new ValueDescription($object->getDataValue());
214	1	}
215
216	4	switch(count($valueDescriptions)) {
217		case 0:
218		throw new EmptyQueryException();
219		case 1:
220		return reset($valueDescriptions);
221		default:
222		return new Disjunction($valueDescriptions);
223		}
224	4	}
225
226	6	private function formatQueryResult(array $subjectIds) {
227	6	$nodes = array();
228
229		foreach($subjectIds as $subjectId) {
230		$nodes[] = new WikibaseResourceNode('', new EntityIdValue($subjectId));
231		}
232
233		return new ResourceListNode($nodes);
234	6	}
235		}
236

ProjetPP / PPP-Wikidata

Pull Request — master (#123)

buildQueryForUnion() B

Complexity

Size

Duplication

Code Coverage

Importance

Available Fixes

Duplication Side-by-Side

Filter issues like