hazendaz / htmlcompressor-maven-plugin / 88

Committed 20 Apr 2025 08:12PM UTC coverage: 36.479% (+0.2%) from 36.249%

Build # 88

Build Type

push

github

Committed by

hazendaz

Commit Message

[maven-release-plugin] prepare for next development iteration

Run Details

44 of 218 branches covered (20.18%)

Branch coverage included in aggregate %.

273 of 651 relevant lines covered (41.94%)

0.42 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

80.0

/src/main/java/com/tunyk/mvn/plugins/htmlcompressor/FileTool.java

/*
 *    Copyright 2011-2025 the original author or authors.
 *
 *    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.
 */
package com.tunyk.mvn.plugins.htmlcompressor;

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<String, String> getFiles() throws IOException {
        ConcurrentMap<String, String> map = new ConcurrentHashMap<>();
        Path rootDir = Path.of(rootDirPath);
        List<Path> paths;
        try (Stream<Path> 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<String, String> map, String targetDir) throws IOException {
        for (Entry<String, String> 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<String, String> map, String targetFile, String integrationCode)
            throws IOException, JSONException {
        String replacePattern = "\"%s\"";
        Path path = Path.of(targetFile);
        JSONObject json = new JSONObject();
        for (Entry<String, String> 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 {
        Path path = Path.of(rootDirPath);
        this.rootDirPath = path.toFile().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;
    }
}

1	/*
2	* Copyright 2011-2025 the original author or authors.
3	*
4	* Licensed under the Apache License, Version 2.0 (the "License");
5	* you may not use this file except in compliance with the License.
6	* You may obtain a copy of the License at
7	*
8	* https://www.apache.org/licenses/LICENSE-2.0
9	*
10	* Unless required by applicable law or agreed to in writing, software
11	* distributed under the License is distributed on an "AS IS" BASIS,
12	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13	* See the License for the specific language governing permissions and
14	* limitations under the License.
15	*/
16	package com.tunyk.mvn.plugins.htmlcompressor;
17
18	import java.io.IOException;
19	import java.nio.charset.Charset;
20	import java.nio.file.Files;
21	import java.nio.file.Path;
22	import java.util.Arrays;
23	import java.util.List;
24	import java.util.Map;
25	import java.util.Map.Entry;
26	import java.util.concurrent.ConcurrentHashMap;
27	import java.util.concurrent.ConcurrentMap;
28	import java.util.regex.Matcher;
29	import java.util.stream.Collectors;
30	import java.util.stream.Stream;
31
32	import org.json.JSONException;
33	import org.json.JSONObject;
34
35	/**
36	* The Class FileTool.
37	*/
38	public class FileTool {
39
40	/** The root dir path. */
41	private String rootDirPath;
42
43	/** The file extensions. */
44	private String[] fileExtensions;
45
46	/** The recursive. */
47	private boolean recursive;
48
49	/** The file encoding. */
50	private Charset fileEncoding;
51
52	/**
53	* Instantiates a new file tool.
54	*
55	* @param rootDir
56	* the root dir
57	* @param fileExtensions
58	* the file ext
59	* @param recursive
60	* the recursive
61	*
62	* @throws IOException
63	* Signals that an I/O exception has occurred.
64	*/
65	public FileTool(String rootDir, String[] fileExtensions, boolean recursive) throws IOException {	1✔
66	this.setRootDirPath(rootDir);	1✔
67	this.fileExtensions = fileExtensions;	1✔
68	this.recursive = recursive;	1✔
69	}	1✔
70
71	/**
72	* Gets the files.
73	*
74	* @return the files
75	*
76	* @throws IOException
77	* Signals that an I/O exception has occurred.
78	*/
79	public ConcurrentMap<String, String> getFiles() throws IOException {
80	ConcurrentMap<String, String> map = new ConcurrentHashMap<>();	1✔
81	Path rootDir = Path.of(rootDirPath);	1✔
82	List<Path> paths;
83	try (Stream<Path> walk = Files.walk(rootDir)) {	1✔
84	paths = walk.map(Path::normalize).filter(Files::isRegularFile)	1✔
85	.filter(path -> Arrays.stream(fileExtensions).anyMatch(path.getFileName().toString()::endsWith))	1✔
86	.collect(Collectors.toList());	1✔
87	}
88	int truncationIndex = 0;	1✔
89	for (Path path : paths) {	1✔
90	String normalizedFilePath = path.toFile().getCanonicalPath().replace("\\", "/");	1✔
91	if (truncationIndex == 0) {	1✔
92	truncationIndex = normalizedFilePath.indexOf(rootDirPath) + rootDirPath.length() + 1;	1✔
93	}
94	String key = normalizedFilePath.substring(truncationIndex);	1✔
95	String value = Files.readString(path, getFileEncoding());	1✔
96	map.put(key, value);	1✔
97	}	1✔
98	return map;	1✔
99	}
100
101	/**
102	* Write files.
103	*
104	* @param map
105	* the map
106	* @param targetDir
107	* the target dir
108	*
109	* @throws IOException
110	* Signals that an I/O exception has occurred.
111	*/
112	public void writeFiles(Map<String, String> map, String targetDir) throws IOException {
113	for (Entry<String, String> entry : map.entrySet()) {	1✔
114	Path path = Path.of(targetDir + '/' + entry.getKey());	1✔
115	Files.createDirectories(path.getParent());	1✔
116	Files.writeString(path, entry.getValue(), getFileEncoding());	1✔
117	}	1✔
118	}	1✔
119
120	/**
121	* Write to json file.
122	*
123	* @param map
124	* the map
125	* @param targetFile
126	* the target file
127	* @param integrationCode
128	* the integration code
129	*
130	* @throws IOException
131	* Signals that an I/O exception has occurred.
132	* @throws JSONException
133	* the JSON exception
134	*/
135	public void writeToJsonFile(Map<String, String> map, String targetFile, String integrationCode)
136	throws IOException, JSONException {
137	String replacePattern = "\"%s\"";	1✔
138	Path path = Path.of(targetFile);	1✔
139	JSONObject json = new JSONObject();	1✔
140	for (Entry<String, String> entry : map.entrySet()) {	1✔
141	json.put(entry.getKey(), entry.getValue());	1✔
142	}	1✔
143	if (integrationCode == null) {	1!
144	integrationCode = replacePattern;	×
145	}
146	if (integrationCode.indexOf(replacePattern) == -1) {	1✔
147	integrationCode += replacePattern;	1✔
148	}
149	String contents = integrationCode.replaceFirst(replacePattern, Matcher.quoteReplacement(json.toString()));	1✔
150	Files.createDirectories(path.getParent());	1✔
151	Files.writeString(path, contents, getFileEncoding());	1✔
152	}	1✔
153
154	/**
155	* Human readable byte count.
156	*
157	* @param bytes
158	* the bytes
159	* @param systemOfUnits
160	* the systemOfUnits
161	*
162	* @return the string
163	*/
164	// 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
165	// per error-prone, so ignoring it
166	@SuppressWarnings("LongDoubleConversion")
167	public static String humanReadableByteCount(long bytes, boolean systemOfUnits) {
168	int unit = systemOfUnits ? 1000 : 1024;	1!
169	if (bytes < unit) {	1!
170	return bytes + " B";	1✔
171	}
172	int exp = (int) (Math.log(bytes) / Math.log(unit));	×
173	String pre = (systemOfUnits ? "kMGTPE" : "KMGTPE").charAt(exp - 1) + (systemOfUnits ? "" : "i");	×
174	return String.format("%.1f %sB", bytes / Math.pow(unit, exp), pre);	×
175	}
176
177	/**
178	* Gets the elapsed HMS time.
179	*
180	* @param elapsedTime
181	* the elapsed time
182	*
183	* @return the elapsed HMS time
184	*/
185	public static String getElapsedHMSTime(long elapsedTime) {
186	String format = String.format("%%0%dd", 2);	1✔
187	elapsedTime = elapsedTime / 1000;	1✔
188	String seconds = String.format(format, elapsedTime % 60);	1✔
189	String minutes = String.format(format, (elapsedTime % 3600) / 60);	1✔
190	String hours = String.format(format, elapsedTime / 3600);	1✔
191	return hours + ":" + minutes + ":" + seconds;	1✔
192	}
193
194	/**
195	* Gets the root dir path.
196	*
197	* @return the root dir path
198	*/
199	public String getRootDirPath() {
200	return rootDirPath;	×
201	}
202
203	/**
204	* Sets the root dir path.
205	*
206	* @param rootDirPath
207	* the new root dir path
208	*
209	* @throws IOException
210	* Signals that an I/O exception has occurred.
211	*/
212	public void setRootDirPath(String rootDirPath) throws IOException {
213	Path path = Path.of(rootDirPath);	1✔
214	this.rootDirPath = path.toFile().getCanonicalPath().replace("\\", "/").replaceAll("/$", "");	1✔
215	}	1✔
216
217	/**
218	* Gets the file extensions.
219	*
220	* @return the file extensions
221	*/
222	public String[] getFileExtensions() {
223	return fileExtensions;	×
224	}
225
226	/**
227	* Sets the file extensions.
228	*
229	* @param fileExtensions
230	* the new file extensions
231	*/
232	public void setFileExtensions(String[] fileExtensions) {
233	this.fileExtensions = fileExtensions;	×
234	}	×
235
236	/**
237	* Checks if is recursive.
238	*
239	* @return true, if is recursive
240	*/
241	public boolean isRecursive() {
242	return recursive;	×
243	}
244
245	/**
246	* Sets the recursive.
247	*
248	* @param recursive
249	* the new recursive
250	*/
251	public void setRecursive(boolean recursive) {
252	this.recursive = recursive;	×
253	}	×
254
255	/**
256	* Gets the file encoding.
257	*
258	* @return the file encoding
259	*/
260	public Charset getFileEncoding() {
261	return fileEncoding == null ? Charset.defaultCharset() : fileEncoding;	1✔
262	}
263
264	/**
265	* Sets the file encoding.
266	*
267	* @param fileEncoding
268	* the new file encoding
269	*/
270	public void setFileEncoding(Charset fileEncoding) {
271	this.fileEncoding = fileEncoding == null ? Charset.defaultCharset() : fileEncoding;	1✔
272	}	1✔
273	}

hazendaz / htmlcompressor-maven-plugin / 88

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous