Visits provided relative path using provided or default session.

@param string      $path
@param string|null $sessionName
11468
public function visitPath($path, $sessionName = null)
    {
        $this->getSession($sessionName)->visit($this->locatePath($path));
    }
1287354
public function setPath($path)
    {
        if (!$this->databaseIsPath) {
            $path = ltrim($path, '/');
        }
        $this->setDatabase($path);
    }
639777
public function open($save_path, $session_name) : bool
    {
        $this->createTableIfNotExists();
        return parent::open($save_path, $session_name);
    }
861315
public function open($save_path, $name)
    {
        $this->_sessionSavePath = $save_path;
        $this->_sessionName     = $name;

        return true;
    }
249690
public function open($savePath, $sessionName)
    {
        if (!isset($this->_lifeTime)) $this->_lifeTime = intval(ini_get("session.gc_maxlifetime"));
        if (!isset($this->_refreshTime)) $this->_refreshTime = ceil($this->_lifeTime / 3);

        $this->_initSessionData = null;

        $this->_memcache = new Memcache();
        if (Kwf_Cache_Simple::$memcacheHost) {
            $servers = array(
                array(
                    'host' => Kwf_Cache_Simple::$memcacheHost,
                    'port' => Kwf_Cache_Simple::$memcachePort
                )
            );
        } else {
            throw new Kwf_Exception("no memcache configured");
        }
        foreach ($servers as $s) {
            if (version_compare(phpversion('memcache'), '2.1.0') == -1 || phpversion('memcache')=='2.2.4') { // < 2.1.0
                $this->_memcache->addServer($s['host'], $s['port'], true, 1, 1, 1);
            } else if (version_compare(phpversion('memcache'), '3.0.0') == -1) { // < 3.0.0
                $this->_memcache->addServer($s['host'], $s['port'], true, 1, 1, 1, true, null, 10000);
            } else {
                $this->_memcache->addServer($s['host'], $s['port'], true, 1, 1, 1);
            }
        }

        return true;
    }
387451
public static function ExistsClassSession ($name = null, $class_path = null) {
		return Session::Exists(static::_GetSeesionClassLayerPath($name, $class_path ?: static::class));
	}
401450
public function open($save_path, $sessionid)
    {
        // we'll ignore $save_path because we have our own path from config

        if (isset($this->config['session_save_path'])) {
            $this->savePath = $this->config['session_save_path'];
        } else {
            $this->savePath = Application::getStoragePath('session');
        }

        if (substr($this->savePath, -1) != DS) {
            $this->savePath .= DS;
        }

        return true;
    }
989406
private function setNodePropertyForSession(SessionInterface $session, $nodePath, $propertyName, $value)
    {
        $session->getNode($nodePath)->setProperty($propertyName, $value);
    }
421351
protected function locateSession($name = null)
    {
        $name = strtolower($name) ?: $this->defaultSessionName;

        if (null === $name) {
            throw new \InvalidArgumentException('Specify session name to get');
        }

        if (!isset($this->sessions[$name])) {
            throw new \InvalidArgumentException(sprintf('Session "%s" is not registered.', $name));
        }

        $session = $this->sessions[$name];

        return $session;
    }
268681
public function seeFileFound($filename, $path = '')
    {
        if ($path === '' && file_exists($filename)) {
            $this->openFile($filename);
            \PHPUnit\Framework\Assert::assertFileExists($filename);
            return;
        }

        $found = $this->findFileInPath($filename, $path);

        if ($found === false) {
            $this->fail("File \"$filename\" not found at \"$path\"");
        }

        $this->openFile($found);
        \PHPUnit\Framework\Assert::assertFileExists($found);
    }
927037
public function setPath($path, $value = null, $method = null)
    {
        $this->paths[$path] = [];

        if (! is_null($value)) {
            $this->paths[$path]['path'] = $value;
        }

        if (! is_null($method)) {
            $this->paths[$path]['method'] = $method;
        }
    }
830463
protected static function setPath($path = null)
    {
        if (!static::$pathStack) {
            $requestURI = parse_url($_SERVER['REQUEST_URI']);
            static::$pathStack = static::$requestPath = explode('/', ltrim($requestURI['path'], '/'));
        }
    
        static::$_path = isset($path) ? $path : static::$pathStack;
    }
327047
private function performFindAndReplaceInFile(
        string $path
    ): void {
        $this->findAndReplaceHelper->findReplace(
            'use ' . RelationsGenerator::FIND_ENTITIES_NAMESPACE . '\\' . RelationsGenerator::FIND_ENTITY_NAME,
            "use {$this->entityFqn}",
            $path
        );
        $this->findAndReplaceHelper->findReplace(
            'use ' .
            RelationsGenerator::FIND_ENTITY_INTERFACE_NAMESPACE .
            '\\' .
            RelationsGenerator::FIND_ENTITY_INTERFACE_NAME,
            "use {$this->entityInterfaceFqn}",
            $path
        );
        $this->findAndReplaceHelper->findReplaceRegex(
            '%use(.+?)Relations\\\TemplateEntity(.+?);%',
            'use ${1}Relations\\' . $this->singularNamespace . '${2};',
            $path
        );
        $this->findAndReplaceHelper->findReplaceRegex(
            '%use(.+?)Relations\\\TemplateEntity(.+?);%',
            'use ${1}Relations\\' . $this->pluralNamespace . '${2};',
            $path
        );
        $this->findAndReplaceHelper->findReplaceRegex(
            '%(Has|Reciprocates)(Required|)TemplateEntity%',
            '${1}${2}' . $this->singularNamespacedName,
            $path
        );
        $this->findAndReplaceHelper->findReplaceRegex(
            '%(Has|Reciprocates)(Required|)TemplateEntities%',
            '${1}${2}' . $this->pluralNamespacedName,
            $path
        );
        $this->findAndReplaceHelper->findReplace(
            RelationsGenerator::FIND_ENTITY_INTERFACE_NAME,
            $this->namespaceHelper->basename($this->entityInterfaceFqn),
            $path
        );
        $this->findAndReplaceHelper->replaceName($this->singularNamespacedName, $path);
        $this->findAndReplaceHelper->replacePluralName($this->pluralNamespacedName, $path);
        $this->findAndReplaceHelper->replaceProjectNamespace($this->projectRootNamespace, $path);
    }
1374283
private function import(SessionInterface $session, $path, $fileName)
    {
        if ($session->nodeExists($path)) {
            $session->getNode($path)->remove();
            $session->save();
        }

        $session->importXML(
            PathHelper::getParentPath($path),
            $fileName,
            ImportUUIDBehaviorInterface::IMPORT_UUID_COLLISION_THROW
        );

        $session->save();
    }
429264
public function open($savePath, $sessionName) {
        try {
            // get table to see if the table exists.
            $this->_tableRestProxy->getTable($this->_sessionContainer);
        } catch (ServiceException $e) {
            // cannot get the table, so create it
            $this->_tableRestProxy->createTable($this->_sessionContainer);
        }
        return TRUE;
    }
22304
public function clickOnBrowsePath($path)
    {
        $this->clickDiscoveryBar('Content browse');
        $this->waitWhileLoading('.is-universaldiscovery-hidden');
        $node = $this->findWithWait('.ez-view-universaldiscoveryview');
        $node = $this->findWithWait('.ez-view-universaldiscoveryfinderview .ez-ud-finder-explorerlevel', $node);

        $this->openFinderExplorerPath($path, $node);
    }
1193551
public function open($save_path, $session_name)
    {
        $this->key = $this->getKey('KEY_' . $session_name);
        return parent::open($save_path, $session_name);
    }