@param string $path

@return DriverInterface
186557
public function none(string $path): DriverInterface
    {
        return new Adapters\None(
            $this,
            $this->imagePath($path)
        );
    }
926792
public function createRuntimeClient($path)
    {
        $kernel = RuntimeKernel::getKernel();

        return new Protocol1RuntimeClient(
            $kernel->getProtocol1RuntimeGoalStateClient(),
            $kernel->getProtocol1RuntimeCurrentStateClient(),
            $path
        );
    }
28796
public function withPath(string $path): self
    {
        $this->assertPresent($path);

        if ($this->path === $path) {
            return $this;
        }

        $clone = clone $this;
        $clone->path = $path;

        return $clone;
    }
686975
public function loadDriver(string $key): DriverInterface
    {
        if (!$this->hasDriver($key)) {
            throw new DriverNotFoundException('Driver you are looking for doesn\'t exist. Make sure that ' . $key . ' driver is properly configured.');
        }

        return $this->drivers[$key]::install($this);
    }
553987
public function assertAtPath($path)
    {
        $this->getSession()->visit($this->locatePath($path));

        // If available, add extra validation that this is a 200 response.
        try {
            $this->getSession()->getStatusCode();
            $this->assertHttpResponse('200');
        } catch (UnsupportedDriverActionException $e) {
            // Simply continue on, as this driver doesn't support HTTP response codes.
        }
    }
695505
public function getVisibility($path)
    {
        if ($this->driver->getVisibility($path) == AdapterInterface::VISIBILITY_PUBLIC) {
            return Filesystem::VISIBILITY_PUBLIC;
        }
        return Filesystem::VISIBILITY_PRIVATE;
    }
1369928
public static function create( $path ) 
	{
		$class = static::find( $path );
		
		// if class already loaded
		if ( !class_exists( $class, false ) ) 
		{
			// register the controller with the autoloader
			\CCFinder::bind( $class, CCPath::get( $path, CCDIR_CONTROLLER, 'Controller'.EXT ) );
		}
		
		// create new controller instance and assign the name
		$controller = new $class;
		$controller->name = $path;
		
		return $controller;
	}
806002
public function cacheDir(string $path): self
    {
        $this->validatePathIsRelativeToProject($path, __METHOD__);
        $this->cacheDir = rtrim($path, '/');

        return $this;
    }
1010131
public function setPath($path)
    {
        $url = parse_url($path);

        $this->path = $url['path'];
        if (isset($url['host'])) {
            $this->setHost($url['host']);
        }

        if (isset($url['query'])) {
            $this->setQuery($url['query']);
        }
        return $this;
    }
1023803
private function addPath($path)
    {
        $path = $this->resolvePath($path);

        if ($this->validatePath($path)) {
            $this->paths[] = $path;
        }

        return $this;
    }
1131116
public function type($path)
	{
		$path = Util::normalizePath($path);

		return $this->adapter->type($path);
	}
1130830
public function findByPath($path)
    {
        $qb = $this->createQueryBuilder('r');

        $query = $qb
            ->andWhere($qb->expr()->eq('r.fromPath', ':path'))
            ->andWhere($qb->expr()->eq('r.enabled', ':enabled'))
            ->getQuery()
            ->setMaxResults(1)
            // TODO cache
        ;

        return $query
            ->setParameters([
                'path' => $path,
                'enabled' => true,
            ])
            ->getOneOrNullResult()
        ;
    }
461896
public function replace($path)
    {
        //argument 1 must be a string
        Argument::i()->test(1, 'string');

        //get the path array
        $pathArray = $this->getArray();

        //pop out the last
        array_pop($pathArray);

        //push in the new
        $pathArray[] = $path;

        //assign back to path
        $this->data = implode('/', $pathArray);

        return $this;
    }
262295
public function withPath($path)
    {
        if (!is_string($path)) {
            throw new \InvalidArgumentException('Invalid path provided; must be a string');
        }
        $path = $this->filterPath($path);

        $new = clone $this;
        $new->path = $path;

        return $new;
    }
25863
public function initAll(string $path): PathInfoInterface
    {
        $this->path = $path;
        [$this->wrappers, $this->root, $this->dirs] = $this->getPathParts();
        return $this;
    }
475286
public function get(string $path): ViewInterface
    {
        if (!empty($this->cache) && $this->cache->has($this->context, $path)) {
            return $this->cache->get($this->context, $path);
        }

        $view = $this->findEngine($path)->get($path, $this->context);

        if (!empty($this->cache)) {
            $this->cache->set($this->context, $path, $view);
        }

        return $view;
    }
553078
protected function normalizeRelativeWindowsPath(
        RelativeWindowsPathInterface $path
    ) {
        if ($path->isAnchored()) {
            $atoms = $this->normalizeAbsolutePathAtoms($path->atoms());
        } else {
            $atoms = $this->normalizeRelativePathAtoms($path->atoms());
        }

        return $this->factory()->createFromDriveAndAtoms(
            $atoms,
            $this->normalizeDriveSpecifier($path->drive()),
            false,
            $path->isAnchored(),
            false
        );
    }