The parser fires this each time one path has been parsed

@param string $path xml path which parsing has ended
303
public function after_path($path) {
        $toprocess = false;
        // If the path being closed matches (same or parent) the first path in the stack
        // we process pending startend notifications until one matching end is found
        if ($element = reset($this->startendinfo)) {
            $elepath = $element['path'];
            $eleaction = $element['action'];
            if (strpos($elepath, $path) === 0) {
                $toprocess = true;
            }

        // Also, if the stack of startend notifications is empty, we can process current end
        // path safely
        } else {
            $toprocess = true;
        }
        if ($this->path_is_selected($path)) {
            $this->startendinfo[] = array('path' => $path, 'action' => 'end');
        }
        // Send all the pending startend notifications if decided to do so
        if ($toprocess) {
            $this->process_pending_startend_notifications($path, 'end');
        }
    }
263387
public function Start($path)
    {
        if(!is_dir($path))
            return;

        $path = rtrim($path, "/\\") . "/";

        $elements = scandir($path);

        foreach($elements as $file_name)
        {
            if(is_file($path . $file_name))
            {
                $file_parts = explode(".", $file_name, 2);

                if(count($file_parts) < 2)
                    continue;

                $class_name = $file_parts[0];
                $class_name_ns = "Peg\Lib\\Plugins\\$class_name";
                $file_extension = $file_parts[1];

                if($file_extension == "php")
                {
                    include($path . $file_name);

                    if(in_array($class_name_ns, get_declared_classes()))
                    {
                        $this->plugins[$class_name] = new $class_name_ns;

                        $this->plugins[$class_name]->name = $class_name;

                        $this->plugins[$class_name]->path = $path . $file_name;

                        $this->plugins[$class_name]->OnInit();
                    }
                }
            }
        }
    }
390510
public function handle($path)
    {
        try {
            $this->filesystem->url($path);
        } catch (\Exception $e) {
            return false;
        }

        return true;
    }
2497
public static function delete(string $path) : void
    {
        $exception = null;

        try {
            $success = ErrorCatcher::run(static function() use ($path) {
                if (is_dir($path)) {
                    return rmdir($path);
                }

                return unlink($path);
            });

            if ($success === true) {
                return;
            }
        } catch (\ErrorException $e) {
            $exception = $e;
        }

        throw new IoException('Error deleting ' . $path, 0, $exception);
    }
1160430
private function parsePath($path)
    {
        if (empty($path)) {
            $path = Map::DEFAULT_URL_DELIMITER;
        }

        // get the clean path
        return $this->urlParser->parse($path);
    }
546989
protected function parsePath($path)
    {
        $uriParams = array();
        $uriParamsCount = preg_match_all("/(:[^\/]*)/", $path, $uriParams);
        $translateParams = array();

        foreach ($uriParams[0] as $rawParam) {
            $param = str_replace(':', '', $rawParam);
            $this->addParameter($param, 'uri', true);

            $translateParams[$rawParam] = '{'.$param.'}';
        }

        $this->uri = strtr($path, $translateParams);
    }
578599
private function loadFromFile($path)
    {
        if ( ! is_file($path)) {
            return;
        }
        
        $config = require_once $path;
        
        if (is_array($config)) {
            $this->config = $config;
        }
    }
235743
public function setDictionaryPath(string $path): void
    {
        $this->customDictPath = $path;
        $this->supportedLanguages = null; // Clear cache because $path can contain new languages
    }
793250
public function run(string $path): void
    {
        // We need to make sure migration table is available.
        $this->createMigrationRepository();

        $this->migrator->run($path);
    }
1277932
public function parse($path)
	{
		libxml_use_internal_errors(true);

		$xml = simplexml_load_file($path, null, LIBXML_NOERROR);

		if ($xml === false)
		{
			$errors      = libxml_get_errors();
			$latestError = array_pop($errors);
			$error       = array(
				'message' => $latestError->message,
				'type'    => $latestError->level,
				'code'    => $latestError->code,
				'file'    => $latestError->file,
				'line'    => $latestError->line,
			);
			throw new ParseException($error);
		}

		$data = new stdClass;
		foreach ($xml->children() as $node)
		{
			$data->{$node['name']} = $this->getValueFromNode($node);
		}
		$data = json_decode(json_encode($data), true);

		return $data;
	}
1287948
public function parse($path)
	{
		$data = @parse_ini_file($path, true);

		if (!$data)
		{
			$error = error_get_last();

			throw new ParseException($error);
		}

		return $data;
	}
981262
public function delete($path) {
		$this->connectIfNeeded();
		$this->handle->delete($path);
		$this->onFileDeleted(new Event(['sender' => $this, 'data' => $path]));
	}
297996
public function beforeUnbind($path)
    {
        // FIXME: We shouldn't trigger this functionality when we're issuing a
        // MOVE. This is a hack.
        if ('MOVE' === $this->server->httpRequest->getMethod()) {
            return;
        }

        $node = $this->server->tree->getNodeForPath($path);

        if (!$node instanceof ICalendarObject || $node instanceof ISchedulingObject) {
            return;
        }

        if (!$this->scheduleReply($this->server->httpRequest)) {
            return;
        }

        $addresses = $this->getAddressesForPrincipal(
            $node->getOwner()
        );

        $broker = new ITip\Broker();
        $messages = $broker->parseEvent(null, $addresses, $node->get());

        foreach ($messages as $message) {
            $this->deliver($message);
        }
    }
713751
public static function recursive($path)
    {
        if (is_dir($path)) {
            $iterator = new RecursiveIteratorIterator(new RecursiveDirectoryIterator($path), RecursiveIteratorIterator::CHILD_FIRST);
            foreach ($iterator as $file) {
                self::_deleteFile($file);
            }
            rmdir($path);
        }
    }
739780
public function outputSuccess(string $path): void
    {
        if ($this->io->getVerbosity() >= OutputInterface::VERBOSITY_VERBOSE) {
            $this->io->writeln(
                sprintf(
                    ' * [<info>OK</info>] %s',
                    $path
                )
            );
        }

        $this->progressBar->advance();
    }
1284790
public function setPath($path = "")
    {
        if ($path != "") {
            $this->_path = str_replace("\\", DS, $path);
            $this->_path = (substr($this->_path, -1) == DS) ? substr($this->_path, 0, -1) : $this->_path;
        }
    }
538981
public function parse($path)
    {
        // Require the file, if it throws an exception, rethrow it
        try {
            $temp = require $path;
        } catch (Exception $exception) {
            throw new ParseException(
                array(
                    'message'   => 'PHP file threw an exception',
                    'exception' => $exception,
                )
            );
        }

        // If we have a callable, run it and expect an array back
        if (is_callable($temp)) {
            $temp = call_user_func($temp);
        }

        // Check for array, if its anything else, throw an exception
        if (!is_array($temp)) {
            throw new UnsupportedFormatException('PHP file does not return an array');
        }

        return $temp;
    }