@param string $path

@return \coverallskit\entity\RepositoryEntity
351257
private function repositoryFromPath($path)
    {
        $directory = $this->resolvePath($path);
        $repository = new GitRepository($directory);

        return $repository;
    }
805941
public function getBundleIdByBaseDir($path)
    {
        $bundleId = null;
        foreach ($this->bundleInfos as $id => $data) {
            if (0 === strpos($path, $data['base_dir'])) {
                $bundleId = $id;
                break;
            }
        }

        return $bundleId;
    }
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;
    }
1148992
public function get(string $path): Image
    {
        $this->assertPresent($path);

        $image = new Image(
            $this->filesystem->read($path),
            $this->filesystem->getMimetype($path),
            $path
        );

        return $image;
    }
314544
protected function createUri(string $path): UriInterface
    {
        $baseUrl = $this->getOption('base_uri', 'https://www.transifex.com');

        return $this->uriFactory->createUri($baseUrl . $path);
    }
1202564
public function getFile($path) {
		$dirPath = realpath($this->path);
		
		if ($dirPath === false) {
			throw new InvalidPath('Path "' . $this->path . '" doesn\'t exists or inaccsessible', null, null, $this->path);
		}
		
		return new File($dirPath . DIRECTORY_SEPARATOR . $path);
	}
683332
public function mapPathEntityId($path)
    {

        // query whether or not a entity ID for the passed path has been mapped
        if (isset($this->pathEntityIdMapping[$path])) {
            return $this->pathEntityIdMapping[$path];
        }

        // throw an exception if not
        throw new \Exception(sprintf('Can\'t map path %s to any entity ID', $path));
    }
38645
protected function normalizePath($path)
    {
        $path = parent::normalizePath($path);
        return $this->getMultiRepositoryPath($path) ?: $path;
    }
938551
public function get(string $path): ?EntityInterface
    {
        $entity = null;

        $name = null;
        $subtree = $this->subtree($path, $name);
        if (null !== $subtree && isset($subtree->ownData[$name])) {
            $entity = $subtree->ownData[$name];
        }

        return $entity;
    }
1174695
private function parsePath($path)
    {
        $parts = explode('/', trim($path, '/'));
        for ($i = 0; $i < 1; $i++) {
            // All paths must contain /{workspace_entityType}
            if (false === $this->issetNotEmpty($i, $parts)) {
                throw RestException::invalidEndpoint($path);
            }
        }
        $this->extractEntityType($parts);
        $this->extractIdentifier($parts);
        $this->extractRelationship($parts);
        return $this;
    }
278870
public function get(string $path): File {
		return (new File(Paths::appendPath($this->getUrl(), $path)))->addFilters($this->recursiveFilter, true);
	}
740209
private function resolvePath($path = null)
    {
        if (null === $path) {
            if (null === $this->path) {
                throw new LogicException('No default Git repository path set.');
            }

            $path = $this->path;
        }

        return $path;
    }
259152
protected function getMultiRepositoryPath($path)
    {
        if ($this->isPathOfMultiRepository($path)) {
            return $path;
        }
        $packageDir = pathinfo($path, PATHINFO_BASENAME);
        if (!strpos($packageDir, self::MULTI_REPO_DELIMITER)) {
            //package cannot be used in multi-repo
            return null;
        }

        $this->defaultPath = $path;
        $arr = explode(self::MULTI_REPO_DELIMITER, $packageDir);
        $baseName = array_shift($arr);

        $customDir = $this->getParentMultiRepoDir();

        if ($customDir) {
            //get vendor name
            $vendor = pathinfo(dirname($path), PATHINFO_BASENAME);
            //get path based upon custom parent dir
            $newPath = $customDir . DIRECTORY_SEPARATOR . $vendor . DIRECTORY_SEPARATOR
                       . $baseName . self::MULTI_REPO_DIRECTORY_SUFFIX;
            if ($this->io->isVeryVerbose()) {
                $this->io->write('    Multi-repository custom path found.');
            }
        } else {
            //make full path to new general multi-repo directory
            $newPath = str_replace(
                $packageDir,
                $baseName . self::MULTI_REPO_DIRECTORY_SUFFIX, //make repo dir name
                $path
            );
            if ($this->io->isVeryVerbose()) {
                $this->io->write('    Multi-repository path will be within the current vendor directory.');
            }
        }
        $this->filesystem->ensureDirectoryExists($newPath);
        return $newPath;
    }
11585
public function buildPublicTmp ( $path ) {
        
        //repository of all themes        
        $repository  = $this->themeRepository();
        $repository  = Filter::realPath($repository);
        
        //repository to access files of themes (symbolically)
        $repository_tmp = $this->getFolderTmpTheme(); 
       
        $pos = strpos( $path, $repository );
        
        if ( $pos === 0)
            return $repository_tmp . substr($path, strlen($repository));

        return $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;
    }
55281
private function createFromEncrypted(string $path): self
    {
        /** @var resource $imageData */
        $imageData = file_get_contents($path);
        $this->workingData = $imageData;
        $this->encrypted = true;
        return $this;
    }