GraphBuilder::union() - Code Metrics - Benestar/asparagus - Measure and Improve Code Quality continuously with Scrutinizer

GraphBuilder::union() A
last analyzed 2016-01-21 18:37 UTC

↳ Parent: GraphBuilder

Complexity

Conditions	2
Paths	2

Size

Total Lines	9
Code Lines	6

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	1

Metric	Value
c	1
b	0
f	1
dl	0
loc	9
rs	9.6666
cc	2
eloc	6
nc	2
nop	1

<?php

namespace Asparagus;

use InvalidArgumentException;

/**
 * Abstraction layer to create graphs for SPARQL queries
 *
 * @todo support filter, optional, union, minus
 *
 * @since 0.3 (package-private since 0.1)
 *
 * @license GNU GPL v2+
 * @author Bene* < [email protected] >
 */
class GraphBuilder {

	/**
	 * @var array nested list of conditions, grouped by subject and predicate
	 */
	private $conditions = array();

	/**
	 * @var string[] list of optional expressions
	 */
	private $optionals = array();

	/**
	 * @var string[] list of filter expressions
	 */
	private $filters = array();

	/**
	 * @var string[] list of unions
	 */
	private $unions = array();

	/**
	 * @var string[] list of subqueries
	 */
	private $subqueries = array();

	/**
	 * @var string
	 */
	private $currentSubject = null;

	/**
	 * @var string
	 */
	private $currentPredicate = null;

	/**
	 * @var ExpressionValidator
	 */
	private $expressionValidator;

	/**
	 * @var UsageValidator
	 */
	private $usageValidator;

	/**
	 * Package-private constructor, use QueryBuilder::newSubgraph instead
	 *
	 * @param UsageValidator $usageValidator
	 * @throws InvalidArgumentException
	 */
	public function __construct( UsageValidator $usageValidator ) {
		$this->expressionValidator = new ExpressionValidator();
		$this->usageValidator = $usageValidator;
	}

	/**
	 * Adds the given triple as a condition.
	 *
	 * @param string $subject
	 * @param string $predicate
	 * @param string $object
	 * @return self
	 * @throws InvalidArgumentException
	 */
	public function where( $subject, $predicate, $object ) {
		$this->expressionValidator->validate( $subject,
			ExpressionValidator::VALIDATE_VARIABLE | ExpressionValidator::VALIDATE_PREFIXED_IRI
		);
		$this->expressionValidator->validate( $predicate,
			ExpressionValidator::VALIDATE_VARIABLE | ExpressionValidator::VALIDATE_PATH
		);
		$this->expressionValidator->validate( $object,
			ExpressionValidator::VALIDATE_VARIABLE | ExpressionValidator::VALIDATE_PREFIXED_IRI | ExpressionValidator::VALIDATE_NATIVE
		);

		$this->usageValidator->trackUsedPrefixes(  $subject . ' ' . $predicate . ' ' . $object );
		$this->usageValidator->trackDefinedVariables( $subject  . ' ' . $predicate . ' ' . $object );

		$this->currentSubject = $subject;
		$this->currentPredicate = $predicate;
		$this->conditions[$subject][$predicate][] = $object;

		return $this;
	}

	/**
	 * Adds the given triple/double/single value as an additional condition
	 * to the previously added condition.
	 *
	 * @param string $subject
	 * @param string|null $predicate
	 * @param string|null $object
	 * @return self
	 * @throws InvalidArgumentException
	 */
	public function also( $subject, $predicate = null, $object = null ) {
		if ( $predicate === null ) {
			$this->where( $this->currentSubject, $this->currentPredicate, $subject );
		} else if ( $object === null ) {
			$this->where( $this->currentSubject, $subject, $predicate );
		} else {
			$this->where( $subject, $predicate, $object );
		}

		return $this;
	}

	/**
	 * Adds the given expression as a filter to this query.
	 *
	 * @param string $expression
	 * @return self
	 * @throws InvalidArgumentException
	 */
	public function filter( $expression ) {
		$this->expressionValidator->validate( $expression, ExpressionValidator::VALIDATE_FUNCTION );

		$this->usageValidator->trackUsedPrefixes( $expression );
		$this->usageValidator->trackUsedVariables( $expression );

		$this->filters[] = '(' . $expression . ')';

		return $this;
	}

	/**
	 * Adds a filter that the given graph or triple exists.
	 *
	 * @param string|GraphBuilder $subject
	 * @param string|null $predicate
	 * @param string|null $object
	 * @return self
	 * @throws InvalidArgumentException
	 */
	public function filterExists( $subject, $predicate = null, $object = null ) {
		$graphBuilder = $this->getGraphBuilder( $subject, $predicate, $object );
		$this->filters[] = 'EXISTS {' . $graphBuilder->getSPARQL() . ' }';

		return $this;
	}

	/**
	 * Adds a filter that the given graph or triple does not exist.
	 *
	 * @param string|GraphBuilder $subject
	 * @param string|null $predicate
	 * @param string|null $object
	 * @return self
	 * @throws InvalidArgumentException
	 */
	public function filterNotExists( $subject, $predicate = null, $object = null ) {
		$graphBuilder = $this->getGraphBuilder( $subject, $predicate, $object );
		$this->filters[] = 'NOT EXISTS {' . $graphBuilder->getSPARQL() . ' }';

		return $this;
	}

	/**
	 * Adds the given graph or triple as an optional condition.
	 *
	 * @param string|GraphBuilder $subject
	 * @param string|null $predicate
	 * @param string|null $object
	 * @return self
	 * @throws InvalidArgumentException
	 */
	public function optional( $subject, $predicate = null, $object = null ) {
		$graphBuilder = $this->getGraphBuilder( $subject, $predicate, $object );
		$this->optionals[] = $graphBuilder->getSPARQL();
		return $this;
	}

	private function getGraphBuilder( $subject, $predicate, $object ) {
		if ( $subject instanceof GraphBuilder ) {
			return $subject;
		}

		$graphBuilder = new GraphBuilder( $this->usageValidator );
		return $graphBuilder->where( $subject, $predicate, $object );
	}

	/**
	 * Adds the given graphs as alternative conditions.
	 *
	 * @param GraphBuilder|GraphBuilder[] $graphs
	 * @return self
	 * @throws InvalidArgumentException
	 */
	public function union( $graphs /* graphs ... */ ) {
		$graphs = is_array( $graphs ) ? $graphs : func_get_args();

		$this->unions[] = implode( ' UNION', array_map( function( GraphBuilder $graph ) {
			return ' {' . $graph->getSPARQL() . ' }';
		}, $graphs ) );

		return $this;
	}

	/**
	 * Adds the given subquery.
	 *
	 * @param QueryBuilder $queryBuilder
	 * @return self
	 * @throws InvalidArgumentException
	 */
	public function subquery( QueryBuilder $queryBuilder ) {
		$this->subqueries[] = $queryBuilder->getSPARQL( false );
		$this->usageValidator->trackDefinedVariables( implode( ' ', $queryBuilder->getSelects() ) );

		// @todo temp hack to add AS definitions to defined variables
		$regexHelper = new RegexHelper();
		$matches = $regexHelper->getMatches( 'AS \{variable}', implode( ' ', $queryBuilder->getSelects() ) );
		$this->usageValidator->trackDefinedVariables( $matches );

		return $this;
	}

	/**
	 * Returns the plain SPARQL string of these conditions.
	 * Surrounding brackets are not included.
	 *
	 * @return string
	 */
	public function getSPARQL() {
		// add subqueries to the beginning because they are logically evaluated first
		$sparql = $this->formatSubqueries();

		foreach ( $this->conditions as $subject => $predicates ) {
			$sparql .= ' ' . $subject;
			$sparql .= $this->formatPredicates( $predicates ) . ' .';
		}

		$sparql .= $this->formatOptionals();
		$sparql .= $this->formatFilters();
		$sparql .= $this->formatUnions();

		return $sparql;
	}

	private function formatPredicates( array $predicates ) {
		return implode( ' ;', array_map( function( $predicate, $objects ) {
			return ' ' . $predicate . ' ' . implode( ' , ', $objects );
		}, array_keys( $predicates ), $predicates ) );
	}

	private function formatOptionals() {
		return implode( array_map( function( $optional ) {
			return ' OPTIONAL {' . $optional . ' }';
		}, $this->optionals ) );
	}

	private function formatFilters() {
		return implode( array_map( function( $filter ) {
			return ' FILTER ' . $filter;
		}, $this->filters ) );
	}

	private function formatUnions() {
		return implode( $this->unions );
	}

	private function formatSubqueries() {
		return implode( array_map( function( $subquery ) {
			return ' { ' . $subquery . ' }';
		}, $this->subqueries ) );
	}

}


1			<?php
2
3			namespace Asparagus;
4
5			use InvalidArgumentException;
6
7			/**
8			* Abstraction layer to create graphs for SPARQL queries
9			*
10			* @todo support filter, optional, union, minus
11			*
12			* @since 0.3 (package-private since 0.1)
13			*
14			* @license GNU GPL v2+
15			* @author Bene* < [email protected] >
16			*/
17			class GraphBuilder {
18
19			/**
20			* @var array nested list of conditions, grouped by subject and predicate
21			*/
22			private $conditions = array();
23
24			/**
25			* @var string[] list of optional expressions
26			*/
27			private $optionals = array();
28
29			/**
30			* @var string[] list of filter expressions
31			*/
32			private $filters = array();
33
34			/**
35			* @var string[] list of unions
36			*/
37			private $unions = array();
38
39			/**
40			* @var string[] list of subqueries
41			*/
42			private $subqueries = array();
43
44			/**
45			* @var string
46			*/
47			private $currentSubject = null;
48
49			/**
50			* @var string
51			*/
52			private $currentPredicate = null;
53
54			/**
55			* @var ExpressionValidator
56			*/
57			private $expressionValidator;
58
59			/**
60			* @var UsageValidator
61			*/
62			private $usageValidator;
63
64			/**
65			* Package-private constructor, use QueryBuilder::newSubgraph instead
66			*
67			* @param UsageValidator $usageValidator
68			* @throws InvalidArgumentException
69			*/
70			public function __construct( UsageValidator $usageValidator ) {
71			$this->expressionValidator = new ExpressionValidator();
72			$this->usageValidator = $usageValidator;
73			}
74
75			/**
76			* Adds the given triple as a condition.
77			*
78			* @param string $subject
79			* @param string $predicate
80			* @param string $object
81			* @return self
82			* @throws InvalidArgumentException
83			*/
84			public function where( $subject, $predicate, $object ) {
85			$this->expressionValidator->validate( $subject,
86			ExpressionValidator::VALIDATE_VARIABLE \| ExpressionValidator::VALIDATE_PREFIXED_IRI
87			);
88			$this->expressionValidator->validate( $predicate,
89			ExpressionValidator::VALIDATE_VARIABLE \| ExpressionValidator::VALIDATE_PATH
90			);
91			$this->expressionValidator->validate( $object,
92			ExpressionValidator::VALIDATE_VARIABLE \| ExpressionValidator::VALIDATE_PREFIXED_IRI \| ExpressionValidator::VALIDATE_NATIVE
93			);
94
95			$this->usageValidator->trackUsedPrefixes( $subject . ' ' . $predicate . ' ' . $object );
96			$this->usageValidator->trackDefinedVariables( $subject . ' ' . $predicate . ' ' . $object );
97
98			$this->currentSubject = $subject;
99			$this->currentPredicate = $predicate;
100			$this->conditions[$subject][$predicate][] = $object;
101
102			return $this;
103			}
104
105			/**
106			* Adds the given triple/double/single value as an additional condition
107			* to the previously added condition.
108			*
109			* @param string $subject
110			* @param string\|null $predicate
111			* @param string\|null $object
112			* @return self
113			* @throws InvalidArgumentException
114			*/
115			public function also( $subject, $predicate = null, $object = null ) {
116			if ( $predicate === null ) {
117			$this->where( $this->currentSubject, $this->currentPredicate, $subject );
118			} else if ( $object === null ) {
119			$this->where( $this->currentSubject, $subject, $predicate );
120			} else {
121			$this->where( $subject, $predicate, $object );
122			}
123
124			return $this;
125			}
126
127			/**
128			* Adds the given expression as a filter to this query.
129			*
130			* @param string $expression
131			* @return self
132			* @throws InvalidArgumentException
133			*/
134			public function filter( $expression ) {
135			$this->expressionValidator->validate( $expression, ExpressionValidator::VALIDATE_FUNCTION );
136
137			$this->usageValidator->trackUsedPrefixes( $expression );
138			$this->usageValidator->trackUsedVariables( $expression );
139
140			$this->filters[] = '(' . $expression . ')';
141
142			return $this;
143			}
144
145			/**
146			* Adds a filter that the given graph or triple exists.
147			*
148			* @param string\|GraphBuilder $subject
149			* @param string\|null $predicate
150			* @param string\|null $object
151			* @return self
152			* @throws InvalidArgumentException
153			*/
154			public function filterExists( $subject, $predicate = null, $object = null ) {
155			$graphBuilder = $this->getGraphBuilder( $subject, $predicate, $object );
156			$this->filters[] = 'EXISTS {' . $graphBuilder->getSPARQL() . ' }';
157
158			return $this;
159			}
160
161			/**
162			* Adds a filter that the given graph or triple does not exist.
163			*
164			* @param string\|GraphBuilder $subject
165			* @param string\|null $predicate
166			* @param string\|null $object
167			* @return self
168			* @throws InvalidArgumentException
169			*/
170			public function filterNotExists( $subject, $predicate = null, $object = null ) {
171			$graphBuilder = $this->getGraphBuilder( $subject, $predicate, $object );
172			$this->filters[] = 'NOT EXISTS {' . $graphBuilder->getSPARQL() . ' }';
173
174			return $this;
175			}
176
177			/**
178			* Adds the given graph or triple as an optional condition.
179			*
180			* @param string\|GraphBuilder $subject
181			* @param string\|null $predicate
182			* @param string\|null $object
183			* @return self
184			* @throws InvalidArgumentException
185			*/
186			public function optional( $subject, $predicate = null, $object = null ) {
187			$graphBuilder = $this->getGraphBuilder( $subject, $predicate, $object );
188			$this->optionals[] = $graphBuilder->getSPARQL();
189			return $this;
190			}
191
192			private function getGraphBuilder( $subject, $predicate, $object ) {
193			if ( $subject instanceof GraphBuilder ) {
194			return $subject;
195			}
196
197			$graphBuilder = new GraphBuilder( $this->usageValidator );
198			return $graphBuilder->where( $subject, $predicate, $object );
199			}
200
201			/**
202			* Adds the given graphs as alternative conditions.
203			*
204			* @param GraphBuilder\|GraphBuilder[] $graphs
205			* @return self
206			* @throws InvalidArgumentException
207			*/
208			public function union( $graphs /* graphs ... */ ) {
209			$graphs = is_array( $graphs ) ? $graphs : func_get_args();
210
211			$this->unions[] = implode( ' UNION', array_map( function( GraphBuilder $graph ) {
212			return ' {' . $graph->getSPARQL() . ' }';
213			}, $graphs ) );
214
215			return $this;
216			}
217
218			/**
219			* Adds the given subquery.
220			*
221			* @param QueryBuilder $queryBuilder
222			* @return self
223			* @throws InvalidArgumentException
224			*/
225			public function subquery( QueryBuilder $queryBuilder ) {
226			$this->subqueries[] = $queryBuilder->getSPARQL( false );
227			$this->usageValidator->trackDefinedVariables( implode( ' ', $queryBuilder->getSelects() ) );
228
229			// @todo temp hack to add AS definitions to defined variables
230			$regexHelper = new RegexHelper();
231			$matches = $regexHelper->getMatches( 'AS \{variable}', implode( ' ', $queryBuilder->getSelects() ) );
232			$this->usageValidator->trackDefinedVariables( $matches );
233
234			return $this;
235			}
236
237			/**
238			* Returns the plain SPARQL string of these conditions.
239			* Surrounding brackets are not included.
240			*
241			* @return string
242			*/
243			public function getSPARQL() {
244			// add subqueries to the beginning because they are logically evaluated first
245			$sparql = $this->formatSubqueries();
246
247			foreach ( $this->conditions as $subject => $predicates ) {
248			$sparql .= ' ' . $subject;
249			$sparql .= $this->formatPredicates( $predicates ) . ' .';
250			}
251
252			$sparql .= $this->formatOptionals();
253			$sparql .= $this->formatFilters();
254			$sparql .= $this->formatUnions();
255
256			return $sparql;
257			}
258
259			private function formatPredicates( array $predicates ) {
260			return implode( ' ;', array_map( function( $predicate, $objects ) {
261			return ' ' . $predicate . ' ' . implode( ' , ', $objects );
262			}, array_keys( $predicates ), $predicates ) );
263			}
264
265			private function formatOptionals() {
266			return implode( array_map( function( $optional ) {
267			return ' OPTIONAL {' . $optional . ' }';
268			}, $this->optionals ) );
269			}
270
271			private function formatFilters() {
272			return implode( array_map( function( $filter ) {
273			return ' FILTER ' . $filter;
274			}, $this->filters ) );
275			}
276
277			private function formatUnions() {
278			return implode( $this->unions );
279			}
280
281			private function formatSubqueries() {
282			return implode( array_map( function( $subquery ) {
283			return ' { ' . $subquery . ' }';
284			}, $this->subqueries ) );
285			}
286
287			}
288

Benestar / asparagus

GraphBuilder::union() A last analyzed 2016-01-21 18:37 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

GraphBuilder::union() A
last analyzed 2016-01-21 18:37 UTC