Package jetbrains.buildServer.util

Class FileUtil

  • public class FileUtil
extends FileUtil

    • Constructor Detail

      • FileUtil

        public FileUtil()

    • Method Detail

      • readFile

        @NotNull
public static List<String> readFile​(@NotNull
                                    File file)
                             throws IOException
        Read list of lines from the file. Each line is terminated by corresponding line feed
        Parameters:
        file - file to read
        Returns:
        list of file lines
        Throws:
        IOException - upon a problem when reading from file
        Since:
        4.0.1

      • readFile

        @NotNull
public static List<String> readFile​(@NotNull
                                    File file,
                                    @NotNull
                                    String encoding)
                             throws IOException
        Read list of lines from the file. Each line is terminated by corresponding line feed
        Parameters:
        file - file to read
        Returns:
        list of file lines
        Throws:
        IOException - upon a problem when reading from file
        Since:
        9.0

      • readText

        @NotNull
public static String readText​(@NotNull
                              File file)
                       throws IOException
        Read the specified text file into a String variable.
        Parameters:
        file - file to read
        Returns:
        file text
        Throws:
        IOException - upon a problem when reading from file
        Since:
        5.0

      • readText

        @NotNull
public static String readText​(@NotNull
                              File file,
                              @NotNull
                              String encoding)
                       throws IOException
        Read the specified text file into a String variable.
        Parameters:
        file - file to read
        encoding - encoding
        Returns:
        file text
        Throws:
        IOException - upon a problem when reading from file
        Since:
        7.1

      • writeFile

        @Deprecated
public static void writeFile​(@NotNull
                             File file,
                             @NotNull
                             String text)
        Deprecated.
        This procedure loses exceptions that is very dangerous. Use writeFileAndReportErrors(java.io.File, java.lang.String) instead.
        TODO rename it to writeFileWithNoExceptions Write text to file and report any errors via LOG.error()
        Parameters:
        file - file to write
        text - text to write to file

      • writeFileAndReportErrors

        public static void writeFileAndReportErrors​(@NotNull
                                            File file,
                                            @NotNull
                                            String text)
                                     throws IOException
        Writes text to file. Throws IO exception if error occurred.
        Parameters:
        file - file to write text to
        text - text to write in file
        Throws:
        IOException - if error occurred
        Since:
        6.5

      • writeFile

        public static void writeFile​(@NotNull
                             File file,
                             @NotNull
                             String text,
                             @NotNull
                             Charset charset)
                      throws IOException
        Creates the file with the parental directories if need and writes the text to the file. Throws IO exception if an error occurred.
        Parameters:
        file - file to write text to
        text - text to write in the file
        charset - encoding (see StandardCharsets)
        Throws:
        IOException - if an error occurred
        Since:
        2020.2

      • writeFile

        public static void writeFile​(@NotNull
                             File file,
                             @NotNull
                             String text,
                             @NotNull
                             String encoding)
                      throws IOException
        Writes text to file. Throws IO exception if error occurred.
        Parameters:
        file - file to write text to
        text - text to write in file
        encoding - encoding
        Throws:
        IOException - if error occurred
        Since:
        7.1

      • parseDocument

        @NotNull
public static org.jdom.Element parseDocument​(@NotNull
                                             File file)
                                      throws org.jdom.JDOMException,
                                             IOException
        Throws:
        org.jdom.JDOMException
        IOException

      • parseDocument

        @NotNull
public static org.jdom.Element parseDocument​(@NotNull
                                             File file,
                                             boolean validate)
                                      throws org.jdom.JDOMException,
                                             IOException
        Throws:
        org.jdom.JDOMException
        IOException

      • parseDocument

        @NotNull
public static org.jdom.Element parseDocument​(@NotNull
                                             InputStream input,
                                             boolean validate)
                                      throws org.jdom.JDOMException,
                                             IOException
        Throws:
        org.jdom.JDOMException
        IOException

      • parseDocument

        @NotNull
public static org.jdom.Element parseDocument​(@NotNull
                                             Reader input,
                                             boolean validate)
                                      throws org.jdom.JDOMException,
                                             IOException
        Throws:
        org.jdom.JDOMException
        IOException
        Since:
        8.0

      • processXmlFile

        public static void processXmlFile​(@NotNull
                                  File file,
                                  @NotNull
                                  FileUtil.Processor processor)
        Updates the file according to the provided processor.

      • saveDocument

        public static void saveDocument​(@NotNull
                                org.jdom.Document document,
                                @NotNull
                                File file)
                         throws IOException
        Throws:
        IOException

      • getFilesSignature

        @NotNull
public static String getFilesSignature​(@NotNull
                                       Collection<File> fileCollection)

      • getTempDirectory

        @NotNull
public static String getTempDirectory()
        Overrides the same method from FileUtil.

      • getFileInSameDir

        @NotNull
public static File getFileInSameDir​(@NotNull
                                    File origFile,
                                    String neededFileName)
        Returns a java.io.File object representing the file located in the same directory as origFile with the given file name

        assert getFileInSameDir(new File("somDir/someFile.txt"), "anotherFile.txt"). equals(new File("someDir/anotherFile.txt"));
        Parameters:
        origFile - original file
        neededFileName - name of required file
        Returns:
        required file

      • moveDirWithContent

        public static boolean moveDirWithContent​(File fromDir,
                                         File to,
                                         FileUtil.ErrorReporter reporter)
        Move directory content from given directory to target location. If there is a problem moving a file, a error is reported via ErrorReporter. Does not override existing target files.
        Parameters:
        fromDir - source directory
        to - target directory
        reporter - used to report text errors during the move
        Returns:
        true if fromDir was moved to to path, false if there were some errors during the move
        Since:
        9.0

      • rename

        public static boolean rename​(@NotNull
                             File from,
                             @NotNull
                             File to,
                             @Nullable
                             FileUtil.ErrorReporter reporter)
        Rename/move file or directory to target location . If there is a problem moving a file, a error is reported via ErrorReporter. If simple rename of a file doesn't work, tries to rename via copy + delete

        Does not override existing target files.

        Parameters:
        from - source file or directory
        to - target file or directory
        reporter - used to report text errors during the move; i.e. if move is not successful, reports a error message.
        Returns:
        true if rename/move was successful, false otherwise
        Since:
        9.0

      • writeViaTmpFile

        public static void writeViaTmpFile​(@NotNull
                                   File targetFile,
                                   @NotNull
                                   InputStream content,
                                   @NotNull
                                   FileUtil.IOAction beforeWriteAction)
                            throws IOException
        Utility to reliably save a file not leaving the file in a corrupted state in case of disk errors or process crash. Writes provided content to the temporary targetFile.new file, closes the input stream, calls provided action, and renames tmp file to the targetFile. Action can be used to make backup copies of the targetFile
        Parameters:
        targetFile - target file
        content - content to write, the stream will be closed after writing
        beforeWriteAction - action to run before renaming temp file to the targetFile
        Throws:
        IOException - in case of IO error
        Since:
        2018.1

      • atomicRename

        public static void atomicRename​(@NotNull
                                File from,
                                @NotNull
                                File to,
                                int maxAttempts)
                         throws IOException
        Renames (moves) the from file to the to file, replacing the second one if exists.
        Throws:
        IOException

      • copyFromResourcesIfNotExist

        public static void copyFromResourcesIfNotExist​(Path appConfFolder,
                                               String fileInResources)

      • renameAndReportErrors

        public static void renameAndReportErrors​(@NotNull
                                         File oldName,
                                         @NotNull
                                         File newName)
                                  throws IOException,
                                         SecurityException
        Renames or moves the give file or directory.

        Performs File.renameTo(java.io.File) but checks the result and throws IOException when the rename is unsuccessful.

        Parameters:
        oldName - old path and name.
        newName - new path and name.
        Throws:
        IOException - when rename is unsuccessful.
        SecurityException - if a security manager exists and it has denied the operation.
        Since:
        8.0

      • sameButDifferInCase

        public static boolean sameButDifferInCase​(@NotNull
                                          File file1,
                                          @NotNull
                                          File file2)
        Check whether the two given paths denotes the same file but in differ cases.

        Note: the result is depend on the actual file system. In unix this function always returns false.

        Parameters:
        file1 - the first file to compare.
        file2 - the second file to compare.
        Returns:
        differ but in case only.
        Since:
        8.0

      • resolvePath

        @NotNull
public static File resolvePath​(@NotNull
                               File baseDir,
                               @NotNull
                               String path)
        If path is absolute, returns path, otherwise it returns path within specified base directory.
        Parameters:
        baseDir - base directory for the resolving the path
        path - path to be resolved, may be absolute or relative for baseDir
        Returns:
        absolute path File

      • copyResource

        @Deprecated
public static void copyResource​(@NotNull
                                String resourceName,
                                @NotNull
                                File outputFile)
        Deprecated.
        Use copyResource(Class, String, java.io.File) to overcome classloader change issues
        Copies contents of the specified resource into the specified file.
        Parameters:
        resourceName - Name of the classpath resource
        outputFile - target file for the resource data

      • copyResource

        public static void copyResource​(@NotNull
                                Class<?> clazz,
                                @NotNull
                                String resourceName,
                                @NotNull
                                File outputFile)
        Copies contents of the specified resource into the specified file. Uses Class.getResourceAsStream(String) in 'clazz' parameter to fetch the resource. NOTE: File will be created even if there was no such resource
        Parameters:
        clazz - class from the class loader that can access the resource
        resourceName - Name of the classpath resource
        outputFile - target file for the resource data

      • copyResourceIfNotExists

        public static void copyResourceIfNotExists​(@NotNull
                                           Class<?> clazz,
                                           @NotNull
                                           String resourceName,
                                           @NotNull
                                           File outputFile)
        Copies the resource file into specified file if it doesn't exist (see copyResource(Class, String, java.io.File)).
        Parameters:
        clazz - class from the class loader that can access the resource
        resourceName - the name of the classpath resource
        outputFile - destination file for the resource data

      • copyResourceWithDist

        public static void copyResourceWithDist​(@NotNull
                                        Class<?> clazz,
                                        @NotNull
                                        String resourceName,
                                        @NotNull
                                        File outputFile)
        Copies the resource file into specified file (see copyResource(Class, String, java.io.File)).

        Handles the '.dist' file as well, i.e.:

        • if the destination file has been changed (if it does not equal to the '.dist' file), only the '.dist' file is copied (thus the destination file is not overwritten);
        • if the destination file has not been changed, or does not exist or the '.dist' file does not exist, both files are copied.
        Parameters:
        clazz - class from the class loader that can access the resource
        resourceName - the name of the classpath resource
        outputFile - destination file for the resource data

      • readResourceAsString

        @Nullable
public static String readResourceAsString​(@NotNull
                                          Class<?> clazz,
                                          @NotNull
                                          String resourceName,
                                          @NotNull
                                          Charset charset)
                                   throws IOException
        Reads the jar resource as a text.
        Parameters:
        clazz - class (used to determine the resource path).
        resourceName - name of resource to read.
        charset - character set of the resource file.
        Returns:
        text from resource, or null if the resource not found.
        Throws:
        IOException - when IO error occurs
        Since:
        6.0

      • copyFilePart

        public static void copyFilePart​(@NotNull
                                File sourceFile,
                                long offset,
                                long length,
                                @NotNull
                                OutputStream destination)
                         throws IOException
        Copies a part of a file to output stream. Stream is closed after part was copied.
        Parameters:
        sourceFile - file to copy
        offset - file offset
        length - length of data
        destination - stream to write to
        Throws:
        IOException - if IOException exception occurs

      • close

        public static void close​(@Nullable
                         Closeable e)
        Closes a resource if it is not null All possible IOExceptions are ignored
        Parameters:
        e - resource to close

      • close

        public static void close​(@Nullable
                         ZipFile e)
        Closes a resource if it is not null All possible IOExceptions are ignored
        Parameters:
        e - resource to close
        Since:
        8.0

      • closeAll

        public static void closeAll​(@NotNull
                            Closeable... toClose)
        Closes all not-null resources All possible IOExceptions are ignored
        Parameters:
        toClose - resources to close
        Since:
        7.0

      • getSubDirectories

        @NotNull
public static List<File> getSubDirectories​(@NotNull
                                           File root)

      • createDir

        @NotNull
public static File createDir​(@NotNull
                             File dir)
                      throws IOException
        Creates directory if it does not exist. Throws IOException if directory creation was not successful.
        Parameters:
        dir - directory to be created
        Returns:
        dir
        Throws:
        IOException - if failed to create directory

      • createEmptyDir

        @NotNull
public static File createEmptyDir​(@NotNull
                                  File dir)
                           throws IOException
        Creates an empty directory, removing all content if it already exists.
        Parameters:
        dir - the directory to create
        Returns:
        result file
        Throws:
        IOException - in case of I/O error occurred

      • getTotalDirectorySize

        public static long getTotalDirectorySize​(@Nullable
                                         File dir)
        Returns the directory size in bytes of files under the specified directory (non recursive).
        Parameters:
        dir - the directory to traverse
        Returns:
        size in bytes

      • getTotalDirectorySize

        public static long getTotalDirectorySize​(@Nullable
                                         File dir,
                                         boolean recursively)
        Returns the directory size in bytes of files under the specified directory recursively.
        Parameters:
        dir - the directory to traverse
        Returns:
        size in bytes
        Since:
        7.1.4

      • deleteIfEmpty

        public static boolean deleteIfEmpty​(@NotNull
                                    File dir)
        Removes directory if it is empty
        Parameters:
        dir - directory to be removed
        Returns:
        true if the directory was removed and false otherwise

      • delete

        @NotNull
public static Set<File> delete​(@NotNull
                               File fileOrDirectory,
                               int numAttempts)
        Removes specified directory or file, for each removed file performs operation up to numAttempts. If directory is provided, all files under this directory will be removed recursively.
        Parameters:
        fileOrDirectory - file or directory to remove
        numAttempts - maximum number of attempts to perform (must be positive)
        Returns:
        set of successfully removed files
        Since:
        8.0

      • symlinkAwareDelete

        @Deprecated
public static void symlinkAwareDelete​(@NotNull
                                      File fileOrDirectory)
        Deprecated.
        use delete(File)
        Removes specified directory or file. On Unix it doesn't remove contents of the symlink dir if it points outside of the fileOrDirectory. On Windows no such checks are performed and this method behaves in the same way as delete(java.io.File).
        Parameters:
        fileOrDirectory - file or directory to remove
        Since:
        9.0

      • symlinkAwareDelete

        @Deprecated
public static void symlinkAwareDelete​(@NotNull
                                      File fileOrDirectory,
                                      @NotNull
                                      FileFilter fileFilter,
                                      int numAttempts)
        Deprecated.
        use delete(File, FileFilter, int)
        Removes specified directory or file, for each removed file performs operation up to numAttempts. On Unix it doesn't remove contents of the symlink dir if it points outside of the fileOrDirectory. On Windows no such checks are performed and this method behaves in the same way as delete(java.io.File, java.io.FileFilter, int).
        Parameters:
        fileOrDirectory - file or directory to remove
        numAttempts - maximum number of attempts to perform (must be positive)
        fileFilter - filter for files, must return true for files to be removed and false otherwise
        Since:
        9.0

      • delete

        @NotNull
public static Set<File> delete​(@NotNull
                               File fileOrDirectory,
                               @NotNull
                               FileFilter fileFilter,
                               int numAttempts)
        Removes specified directory or file, for each removed file performs operation up to numAttempts
        Parameters:
        fileOrDirectory - file or directory to remove
        numAttempts - maximum number of attempts to perform (must be positive)
        fileFilter - filter for files, must return true for files to be removed and false otherwise
        Returns:
        set of successfully removed files
        Since:
        8.0

      • delete

        @NotNull
public static Set<File> delete​(@NotNull
                               File fileOrDirectory,
                               @NotNull
                               FileFilter fileFilter,
                               int numAttempts,
                               @Nullable
                               FileUtil.FilesDeleteListener deleteListener)
        Removes files in fileOrDirectory, skipping all files that do not match fileFilter as well as all their subtitles/subfolders if fileFilter is a directory. Be aware using the method in cases when directory may contain lot of files (>100k). Because of implementation this method requires O(n) memory because it collects visited and removed files. It may cause OOME (especially on agent side) just because a lot of File instances and not so much available memory on agent see TW-67058

      • delete

        public static boolean delete​(@NotNull
                             File file)
        Removes specified file or directory, same as FileUtil.delete(file, 10).
        Parameters:
        file - file or directory to remove
        Returns:
        true if file or directory was removed and false otherwise

      • deleteDirNative

        public static boolean deleteDirNative​(@NotNull
                                      File dir)
                               throws ExecutionException
        Deletes dir using native command rd for windows and rm for *nix
        Parameters:
        dir - - dir to delete
        Returns:
        true, if delete process returned 0 and target dir doesn't exist anymore, false otherwise
        Throws:
        ExecutionException

      • deleteFiles

        public static Collection<File> deleteFiles​(@NotNull
                                           Collection<File> filesToDelete)
        Deletes the given files, in several attempts, if needed.
        Parameters:
        filesToDelete - files to delete - files only, not directories. The files that don't exist are silently ignored.
        Returns:
        if all files were successfully deleted - an empty collection; or the files we could not to delete.
        Since:
        8.1

      • isEmptyDir

        public static boolean isEmptyDir​(@NotNull
                                 File dir)
        Returns true if directory is empty or does not exist and false otherwise.
        Parameters:
        dir - directory
        Returns:
        true if dir is empty or does not exist

      • isReadonly

        public static boolean isReadonly​(@NotNull
                                 File file)
        Returns true if file is readonly and false otherwise
        Parameters:
        file - file
        Returns:
        true if file is readonly

      • fixDirectoryName

        @NotNull
public static String fixDirectoryName​(@NotNull
                                      String name)
        Fixes directory name: replaces all dangerous characters with '_'.
        Parameters:
        name - name of the directory to fix
        Returns:
        name with all 'dangerous' characters replaced with '_'

      • fixDirectoryNameAllowUnicode

        @NotNull
public static String fixDirectoryNameAllowUnicode​(String name)
        Fixes directory name in relaxed manner. Replaces dangerous punctuation with '_'. Allows symbols of unicode "Letter" category.
        Parameters:
        name - name of the directory to fix
        Returns:
        fixed name.

      • isBadDirectoryName

        public static boolean isBadDirectoryName​(@NotNull
                                         String name)
        Checks whether specified name contains dangerous characters which might prevent successful directory creation.
        Parameters:
        name - name to check (just name not path)
        Returns:
        true if directory with given name cannot be created because of invalid characters in it

      • normalizeSeparator

        @NotNull
public static String normalizeSeparator​(@NotNull
                                        String filePath)
        Replace all separators like / and \ to File.separatorChar
        Parameters:
        filePath - path to ve normalized
        Returns:
        path with replaced separators

      • normalizeRelativePath

        @NotNull
public static String normalizeRelativePath​(@NotNull
                                           String path)
        Normalizes relative path by eliminating all possible path/../ /./ ./path combinations Doesn't check if the provided path is relative, but may return unexpected result for absolute paths.
        Parameters:
        path - relative path
        Returns:
        normalized paths with all slashes replaced with '/' and all dot combinations removed (if possible)
        Since:
        4.0.2

      • normalizeAbsolutePath

        @NotNull
public static String normalizeAbsolutePath​(@NotNull
                                           String path)
        Normalizes absolute path by eliminating all possible path/../ /./ ./path combinations. Throws IllegalArgumentException if the specified path is not absolute (in terms of java.io.File#isAbsolute()).
        Parameters:
        path - absolute path
        Returns:
        normalized paths with all slashes replaced with File.separatorChar and all dot combinations removed (if possible)
        Throws:
        IllegalArgumentException - if the specified path is not absolute.
        Since:
        9.0

      • sortFiles

        public static void sortFiles​(@NotNull
                             File[] files)

      • getCommonParentFile

        @Nullable
public static File getCommonParentFile​(@NotNull
                                       File file1,
                                       @NotNull
                                       File file2)

      • getCommonParent

        @NotNull
@Deprecated
public static String getCommonParent​(@NotNull
                                     String firstUrl,
                                     @NotNull
                                     String secondUrl)
        Deprecated.

      • isFileSeparator

        public static boolean isFileSeparator​(char c1)

      • getCanonicalFile

        @NotNull
public static File getCanonicalFile​(@NotNull
                                    File file)
        Attempts to obtain canonical file from the specified file and if it fails returns absolute file.
        Parameters:
        file - file
        Returns:
        see above

      • checkTmpDir

        public static void checkTmpDir()
        Checks if it is allowed to use tmpDir taken from "java.io.tmpdir" system property
        Throws:
        IllegalStateException - if there is no access to temp dir.

      • findFile

        @Nullable
public static File findFile​(@NotNull
                            FileFilter filter,
                            @NotNull
                            File... directories)
        Searches for a file in the specified directories recursively.
        Parameters:
        filter - filter which checks whether file is acceptable
        directories - directories to search for (recursively)
        Returns:
        first found file or null

      • findFiles

        @NotNull
public static Collection<File> findFiles​(@NotNull
                                         FileFilter filter,
                                         @NotNull
                                         File... directories)
        Searches for files in the specified directories recursively.
        Parameters:
        filter - filter which checks whether file is acceptable
        directories - directories to search for (recursively)
        Returns:
        all found files

      • listFilesRecursively

        public static <C extends Collection<String>> C listFilesRecursively​(@NotNull
                                                                    File dir,
                                                                    @NotNull
                                                                    String prefix,
                                                                    boolean includeDirs,
                                                                    int depthLimit,
                                                                    @Nullable
                                                                    Predicate<File> predicate,
                                                                    @NotNull
                                                                    C collection)
        Traverses the given directory and retrieves all files (and nested directories, if specified). Puts the found files and directories into the given collection as strings, where each string is a relative path from the given directory, with '/' path separator (independent on the current OS).

        If the includeDirs option is false, only files are listed. Empty directories are skipped. If this option is true, all directories are included (empty and non-empty) as separated entries.

        Type Parameters:
        C - type of the destination collection.
        Parameters:
        dir - directory to travers.
        prefix - prefix that will be able to each entry.
        includeDirs - include directories as separated entries.
        depthLimit - recursion depth; 0 means non-recursive; Integer.MAX_VALUE means infinite depth.
        predicate - a predicate that is applied to each file or directory; if not met - file or directory will not be included and the directory will not be traversed in.
        collection - destination collection where to put found file entries (must be writable).
        Returns:
        the given destination collection.
        Since:
        7.1

      • listFiles

        @NotNull
public static File[] listFiles​(@NotNull
                               File directory,
                               @NotNull
                               FilenameFilter filter)
        A simple wrapper around file.listFiles(filter) that handles possible null result. In this case an empty array is returned.
        Parameters:
        directory - the file
        filter - the filter to apply
        Returns:
        the array of inner file names (possibly empty)

      • listFiles

        @NotNull
public static File[] listFiles​(@NotNull
                               File directory)
        A simple wrapper around file.listFiles(filter) that handles possible null result. In this case an empty array is returned.
        Parameters:
        directory - the file
        Returns:
        the array of inner file names (possibly empty)
        Since:
        2022.1

      • getFreeSpace

        @Nullable
public static Long getFreeSpace​(@NotNull
                                File file)
        Computes free space on the disk that contains a file
        Parameters:
        file - file to select disk
        Returns:
        free space in bytes or null is operation is not supported by current JVM
        Since:
        5.0

      • getFreeSpaceKB

        @Deprecated
@NotNull
public static Long getFreeSpaceKB​(@NotNull
                                  File dir)
                           throws IOException
        Deprecated.
        since 10.0. Use getFreeSpaceBytesSafe(File) instead
        Gets free space in kilobytes
        Parameters:
        dir - path to get free space for
        Returns:
        free space in kilobytes
        Throws:
        IOException - if an error occurs when finding the free space

      • getFreeSpaceBytesSafe

        @NotNull
public static Long getFreeSpaceBytesSafe​(@NotNull
                                         File dir)
                                  throws IOException
        Gets free space in bytes avoiding Long overflow if free space exceeds 2^63 bytes
        Parameters:
        dir - path to get free space for
        Returns:
        actual free space in bytes, if space does not exceed 2^63, Long.MAX_VALUE otherwise
        Throws:
        IOException - if an error occurs when finding the free space

      • areTheSame

        public static boolean areTheSame​(@Nullable
                                 File file1,
                                 @Nullable
                                 File file2)
                          throws IOException
        Checks that both file pointers specify the same object. So, in Linux it should denote symbolic links. In Windows it should take into account that names are case insensitive.

        Note: it also returns true if both pointers are null.

        Parameters:
        file1 - the first file pointer.
        file2 - the second file pointer.
        Returns:
        sameness.
        Throws:
        IOException

      • convertAntToRegexp

        @NotNull
public static String convertAntToRegexp​(@NotNull
                                        String antPattern)

      • convertAntToRegexp

        @NotNull
public static String convertAntToRegexp​(@NotNull
                                        String antPattern,
                                        boolean ignoreStartingSlash)
        Parameters:
        antPattern - ant-style path pattern
        Returns:
        java regexp pattern. Note that no matter whether forward or backward slashes were used in the antPattern the returned regexp pattern will use forward slashes ('/') as file separators. Paths containing windows-style backslashes must be converted before matching against the resulting regexp
        See Also:
        FileUtil.toSystemIndependentName(java.lang.String)

      • getExtension

        @NotNull
public static String getExtension​(@NotNull
                                  String fileNameWithDirectory)
        Unlike com.intellij.openapi.util.io.FileUtil.getExtension, can use this with full file name (including directory name).
        Parameters:
        fileNameWithDirectory - full file name including directory
        Returns:
        file extension

      • getNameWithoutExtension

        @NotNull
public static String getNameWithoutExtension​(@NotNull
                                             File file)

      • getNameWithoutExtension

        @NotNull
public static String getNameWithoutExtension​(@NotNull
                                             String name)

      • getName

        @NotNull
public static String getName​(@NotNull
                             String path)
        Gets name of the file in platform-independent way (unlike new File(path).getName()) For directories, gets name of the directory
        Since:
        2018.1.2

      • setExectuableAttribute

        public static void setExectuableAttribute​(@NotNull
                                          String path,
                                          boolean executableFlag)
                                   throws IOException
        Set executable attribute, it makes sense only on non-windows platforms.
        Parameters:
        path - the path to use
        executableFlag - new value of executable attribute
        Throws:
        IOException - if there is a problem with setting the flag

      • checkContentEqual

        public static boolean checkContentEqual​(@NotNull
                                        File file1,
                                        @NotNull
                                        File file2)
        Check both files exist and are same byte-by-byte.
        Parameters:
        file1 - first file
        file2 - second file
        Returns:
        true if both files exist and have exactly same content

      • haveEqualContentIgnoringLineEndings

        public static boolean haveEqualContentIgnoringLineEndings​(@NotNull
                                                          File file1,
                                                          @NotNull
                                                          File file2)
                                                   throws IOException
        Check both files exist and have same content ignoring line-endings and leading/trailing spaces.
        Parameters:
        file1 - first file
        file2 - second file
        Returns:
        true if both files exist and have same content
        Throws:
        IOException

      • isAncestor

        public static boolean isAncestor​(@NotNull
                                 File ancestor,
                                 @NotNull
                                 File file,
                                 boolean strict)
        Check if the ancestor is an ancestor of file. Overrides the same method from FileUtil. Please do not use the method from super class directly - it can cause the compilation problems.
        Parameters:
        ancestor - the file
        file - the file
        strict - if false then this method returns true if ancestor and file are equal
        Returns:
        true if ancestor is parent of file; false otherwise

      • isBinaryFile

        public static boolean isBinaryFile​(@NotNull
                                   File file)
                            throws IOException
        Returns whether a specified file is a binary file.
        Parameters:
        file - the file to analyse
        Returns:
        true iff file is binary
        Throws:
        IOException - in case of I/O errors

      • isBinaryData

        public static boolean isBinaryData​(@NotNull
                                   byte[] data,
                                   int size)
        Returns whether specified byte array represents binary data (not text)
        Parameters:
        data - the byte array
        size - size to check
        Returns:
        true iff data array represents binary data

      • isTextData

        public static boolean isTextData​(@NotNull
                                 byte[] data,
                                 int size)
        Returns whether specified byte array represents text data (not binary)
        Parameters:
        data - the byte array
        size - size to check
        Returns:
        true iff data array represents text data

      • isSymlink

        public static boolean isSymlink​(@NotNull
                                File file)
        Checks whether file is a symlink by resolving absolute path into real (canonical) one

        Note that if NIO.2 API is unavailable (Java 1.6 and earlier), symbolic links can't be reliably detected in the following cases:

        • broken links in UNIX (link -> nonexistent, indirectly detectable via checking that File.isFile() and File.isDirectory()) both return false;
        • (broken) links referencing themselves in UNIX (link -> link);
        • (broken) cyclic links in UNIX (link0 -> link1, link1 -> link0);
        • NTFS links.

        Hard links (to files, Windows(NTFS)/Linux/Solaris) and directory junctions (NTFS) are not detectable even using NIO.2 API.

        Parameters:
        file - to check
        Returns:
        true if the file is a symlink, false otherwise
        Since:
        8.1

      • createSymlink

        public static boolean createSymlink​(@NotNull
                                    File target,
                                    @NotNull
                                    File symlinkFile)
        Attempts to create a symlink at symlinkFile that points to target
        Parameters:
        target - - file or directory that symlink will point to
        symlinkFile - - a symlink location
        Returns:
        true if symlink was created and points to the desired file/directory.
        false otherwise
        Since:
        8.1

      • getNameOrAbsolutePath

        public static String getNameOrAbsolutePath​(@NotNull
                                           File baseDir,
                                           @NotNull
                                           File checkDir)
        Checks whether directory lies directly under baseDir. Returns its name when true and absolute path otherwise.
        Parameters:
        checkDir - - dir to check
        baseDir - - base dir to check against
        Returns:
        checkDir name, if it lies directly under baseDir and absolute path of checkDir otherwise.
        Since:
        8.1

      • getUTF8Reader

        public static Reader getUTF8Reader​(@NotNull
                                   File file)
                            throws FileNotFoundException
        Returns Reader with utf-8 encoding to read the file, because FileReader uses default platform encoding
        Parameters:
        file - file to read
        Returns:
        Reader to use
        Throws:
        FileNotFoundException - if FileNotFoundException exception occurs