com.tunyk.mvn.plugins.htmlcompressor.FileTool Maven / Gradle / Ivy

Go to download
/*
 * Copyright (c) 2011-2024 Alex Tunyk .
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *   https://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 * See the NOTICE file distributed with this work for additional information
 * regarding copyright ownership.
 */
package com.tunyk.mvn.plugins.htmlcompressor;

import java.io.File;
import java.io.IOException;
import java.nio.charset.Charset;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
import java.util.regex.Matcher;
import java.util.stream.Collectors;
import java.util.stream.Stream;

import org.json.JSONException;
import org.json.JSONObject;

/**
 * The Class FileTool.
 */
public class FileTool {

    /** The root dir path. */
    private String rootDirPath;

    /** The file extensions. */
    private String[] fileExtensions;

    /** The recursive. */
    private boolean recursive;

    /** The file encoding. */
    private Charset fileEncoding;

    /**
     * Instantiates a new file tool.
     *
     * @param rootDir
     *            the root dir
     * @param fileExtensions
     *            the file ext
     * @param recursive
     *            the recursive
     *
     * @throws IOException
     *             Signals that an I/O exception has occurred.
     */
    public FileTool(String rootDir, String[] fileExtensions, boolean recursive) throws IOException {
        this.setRootDirPath(rootDir);
        this.fileExtensions = fileExtensions;
        this.recursive = recursive;
    }

    /**
     * Gets the files.
     *
     * @return the files
     *
     * @throws IOException
     *             Signals that an I/O exception has occurred.
     */
    public ConcurrentMap getFiles() throws IOException {
        ConcurrentMap map = new ConcurrentHashMap<>();
        Path rootDir = Path.of(rootDirPath);
        List paths;
        try (Stream walk = Files.walk(rootDir)) {
            paths = walk.map(Path::normalize).filter(Files::isRegularFile)
                    .filter(path -> Arrays.stream(fileExtensions).anyMatch(path.getFileName().toString()::endsWith))
                    .collect(Collectors.toList());
        }
        int truncationIndex = 0;
        for (Path path : paths) {
            String normalizedFilePath = path.toFile().getCanonicalPath().replace("\\", "/");
            if (truncationIndex == 0) {
                truncationIndex = normalizedFilePath.indexOf(rootDirPath) + rootDirPath.length() + 1;
            }
            String key = normalizedFilePath.substring(truncationIndex);
            String value = Files.readString(path, getFileEncoding());
            map.put(key, value);
        }
        return map;
    }

    /**
     * Write files.
     *
     * @param map
     *            the map
     * @param targetDir
     *            the target dir
     *
     * @throws IOException
     *             Signals that an I/O exception has occurred.
     */
    public void writeFiles(Map map, String targetDir) throws IOException {
        for (Entry entry : map.entrySet()) {
            Path path = Path.of(targetDir + '/' + entry.getKey());
            Files.createDirectories(path.getParent());
            Files.writeString(path, entry.getValue(), getFileEncoding());
        }
    }

    /**
     * Write to json file.
     *
     * @param map
     *            the map
     * @param targetFile
     *            the target file
     * @param integrationCode
     *            the integration code
     *
     * @throws IOException
     *             Signals that an I/O exception has occurred.
     * @throws JSONException
     *             the JSON exception
     */
    public void writeToJsonFile(Map map, String targetFile, String integrationCode)
            throws IOException, JSONException {
        String replacePattern = "%s";
        Path path = Path.of(targetFile);
        JSONObject json = new JSONObject();
        for (Entry entry : map.entrySet()) {
            json.put(entry.getKey(), entry.getValue());
        }
        if (integrationCode == null) {
            integrationCode = replacePattern;
        }
        if (integrationCode.indexOf(replacePattern) == -1) {
            integrationCode += replacePattern;
        }
        String contents = integrationCode.replaceFirst(replacePattern, Matcher.quoteReplacement(json.toString()));
        Files.createDirectories(path.getParent());
        Files.writeString(path, contents, getFileEncoding());
    }

    /**
     * Human readable byte count.
     *
     * @param bytes
     *            the bytes
     * @param systemOfUnits
     *            the systemOfUnits
     *
     * @return the string
     */
    // TODO JWL 4/22/2023 Didn't see a good way to handle as it gets flagged to remove unnecessary cast if I fix this
    // per error-prone, so ignoring it
    @SuppressWarnings("LongDoubleConversion")
    public static String humanReadableByteCount(long bytes, boolean systemOfUnits) {
        int unit = systemOfUnits ? 1000 : 1024;
        if (bytes < unit) {
            return bytes + " B";
        }
        int exp = (int) (Math.log(bytes) / Math.log(unit));
        String pre = (systemOfUnits ? "kMGTPE" : "KMGTPE").charAt(exp - 1) + (systemOfUnits ? "" : "i");
        return String.format("%.1f %sB", bytes / Math.pow(unit, exp), pre);
    }

    /**
     * Gets the elapsed HMS time.
     *
     * @param elapsedTime
     *            the elapsed time
     *
     * @return the elapsed HMS time
     */
    public static String getElapsedHMSTime(long elapsedTime) {
        String format = String.format("%%0%dd", 2);
        elapsedTime = elapsedTime / 1000;
        String seconds = String.format(format, elapsedTime % 60);
        String minutes = String.format(format, (elapsedTime % 3600) / 60);
        String hours = String.format(format, elapsedTime / 3600);
        return hours + ":" + minutes + ":" + seconds;
    }

    /**
     * Gets the root dir path.
     *
     * @return the root dir path
     */
    public String getRootDirPath() {
        return rootDirPath;
    }

    /**
     * Sets the root dir path.
     *
     * @param rootDirPath
     *            the new root dir path
     *
     * @throws IOException
     *             Signals that an I/O exception has occurred.
     */
    public void setRootDirPath(String rootDirPath) throws IOException {
        File file = new File(rootDirPath);
        this.rootDirPath = file.getCanonicalPath().replace("\\", "/").replaceAll("/$", "");
    }

    /**
     * Gets the file extensions.
     *
     * @return the file extensions
     */
    public String[] getFileExtensions() {
        return fileExtensions;
    }

    /**
     * Sets the file extensions.
     *
     * @param fileExtensions
     *            the new file extensions
     */
    public void setFileExtensions(String[] fileExtensions) {
        this.fileExtensions = fileExtensions;
    }

    /**
     * Checks if is recursive.
     *
     * @return true, if is recursive
     */
    public boolean isRecursive() {
        return recursive;
    }

    /**
     * Sets the recursive.
     *
     * @param recursive
     *            the new recursive
     */
    public void setRecursive(boolean recursive) {
        this.recursive = recursive;
    }

    /**
     * Gets the file encoding.
     *
     * @return the file encoding
     */
    public Charset getFileEncoding() {
        return fileEncoding == null ? Charset.defaultCharset() : fileEncoding;
    }

    /**
     * Sets the file encoding.
     *
     * @param fileEncoding
     *            the new file encoding
     */
    public void setFileEncoding(Charset fileEncoding) {
        this.fileEncoding = fileEncoding == null ? Charset.defaultCharset() : fileEncoding;
    }
}