rdx\jsonpathstreamer\PathAwareJsonListener

Complexity

Total Complexity

27

Size/Duplication

Total Lines	195
Duplicated Lines	0 %

Coupling/Cohesion

Components	2
Dependencies	2

Importance

Changes

0

18 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	5	2
A	endDocument()	0	5	2
A	startObject()	0	9	2
A	endObject()	0	4	1
A	startArray()	0	10	2
A	endArray()	0	5	1
A	key()	0	6	1
A	value()	0	8	1
B	touch()	0	19	6
A	stop()	0	3	1
A	composeKey()	0	3	1
A	arrayKey()	0	6	2
A	setValue()	0	7	2
A	rememberValue()	0	3	1
A	getValue()	0	3	1
A	stopAfter()	0	3	1
	gotPath()	0	1	?
	gotValue()	0	1	?

<?php

namespace rdx\jsonpathstreamer;

use JsonStreamingParser\Listener\IdleListener;

abstract class PathAwareJsonListener extends IdleListener {

	protected $stopAfter = [];
	protected $separator = '/';

	protected $value = [];

	protected $indent = -1;
	protected $array = [false];
	protected $array_index = [-1];
	protected $lastKey = null;
	protected $trace = [];
	protected $key = [];

	/**
	 *
	 */
	public function __construct() {
		if ($regexes = $this->stopAfter()) {
			$this->stopAfter = array_combine($regexes, array_fill(0, count($regexes), false));
		}
	}

	/**
	 * Implements JsonStreamingParser\Listener::endDocument().
	 */
	public function endDocument() {
		if (!empty($this->stopAfter)) {
			$this->stop(false);
		}
	}

	/**
	 * Implements JsonStreamingParser\Listener::startObject().
	 */
	public function startObject() {
		$this->arrayKey();

		$this->indent++;
		$this->array[$this->indent] = false;
		if ($this->lastKey !== null) {
			$this->trace[] = $this->lastKey;
		}
	}

	/**
	 * Implements JsonStreamingParser\Listener::endObject().
	 */
	public function endObject() {
		$this->indent--;
		array_pop($this->trace);
	}

	/**
	 * Implements JsonStreamingParser\Listener::startArray().
	 */
	public function startArray() {
		$this->arrayKey();

		$this->indent++;
		$this->array[$this->indent] = true;
		$this->array_index[$this->indent] = -1;
		if ($this->lastKey !== null) {
			$this->trace[] = $this->lastKey;
		}
	}

	/**
	 * Implements JsonStreamingParser\Listener::endArray().
	 */
	public function endArray() {
		$this->array[$this->indent] = false;
		$this->indent--;
		array_pop($this->trace);
	}

	/**
	 * Implements JsonStreamingParser\Listener::key().
	 */
	public function key($key) {
		$this->lastKey = $key;
		$this->composeKey();

		$this->gotPath($this->path);

The property path does not exist. Did you maybe forget to declare it?

	}

	/**
	 * Implements JsonStreamingParser\Listener::value().
	 */
	public function value($value) {
		$this->arrayKey();
		$this->composeKey();

		$this->touch($this->path);

		$this->gotValue($this->path, $value);
	}

	/**
	 *
	 */
	protected function touch(array $path) {
		if ($this->stopAfter) {

The expression $this->stopAfter of type array is implicitly converted to a boolean; are you sure this is intended? If so, consider using ! empty($expr) instead to make it clear that you intend to check for an array without elements.

			$pathString = implode($this->separator, $path);
			foreach ($this->stopAfter as $regex => &$touched) {
				if (preg_match($regex, $pathString)) {
					$touched = true;
				}
				elseif ($touched) {
					unset($this->stopAfter[$regex]);

					if (empty($this->stopAfter)) {
						$this->stop(true);
					}
				}

				unset($touched);
			}
		}
	}

	/**
	 *
	 */
	protected function stop($allTouched) {
		throw new DoneParsingException($allTouched);
	}

	/**
	 * Create a complete key from the trace and current level.
	 */
	protected function composeKey() {
		$this->path = array_merge($this->trace, [$this->lastKey]);
	}

	/**
	 * Trigger a new key, numeric or associative.
	 */
	protected function arrayKey() {
		if (!empty($this->array[$this->indent])) {
			$this->array_index[$this->indent]++;
			$this->key($this->array_index[$this->indent]);
		}
	}

	/**
	 * Optional helper to save a scalar value into a non-scalar path.
	 */
	protected function setValue(array &$container, array $key, $value) {
		$element = &$container;
		foreach ($key as $subkey) {
			$element =& $element[$subkey];
		}
		$element = $value;
	}

	/**
	 * Remember a value into the provided value property.
	 */
	protected function rememberValue(array $path, $value) {
		$this->setValue($this->value, $path, $value);
	}

	/**
	 * Return the entire saved value.
	 */
	public function getValue() {
		return $this->value;
	}

	/**
	 * Define a list of paths (regexes) that must be completed. Completely stops
	 * the parser after these.
	 *
	 * @return array
	 */
	public function stopAfter() {
		// Optional
	}

	/**
	 * Get notified about a new key, value still unknown.
	 *
	 * @return void
	 */
	abstract public function gotPath(array $path);

	/**
	 * Get notified about a new value, including complete path.
	 *
	 * @return void
	 */
	abstract public function gotValue(array $path, $value);

}