#3642

Committed 23 Oct 2023 02:33PM UTC coverage: 75.784% (+1.4%) from 74.413%

Build # #3642

Build Type

push

Committed by

Commit Message

Sonar code smell issue fixes (#4450)

Signed-off-by: Gino Augustine <ginoaugustine@gmail.com>

Run Details

200 of 200 new or added lines in 39 files covered. (100.0%)

44390 of 58574 relevant lines covered (75.78%)

0.76 hits per line

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

90.96

/opengrok-web/src/main/java/org/opengrok/web/DirectoryListing.java

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * See LICENSE.txt included in this distribution for the specific
 * language governing permissions and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at LICENSE.txt.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */

/*
 * Copyright (c) 2005, 2022, Oracle and/or its affiliates. All rights reserved.
 * Portions Copyright (c) 2011, Jens Elkner.
 * Portions Copyright (c) 2017, 2020, Chris Fraire <cfraire@me.com>.
 */
package org.opengrok.web;

import java.io.File;
import java.io.IOException;
import java.io.Writer;
import java.text.Format;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Locale;
import java.util.Objects;
import java.util.Optional;
import java.util.logging.Level;
import java.util.logging.Logger;

import org.jetbrains.annotations.Nullable;
import org.jetbrains.annotations.VisibleForTesting;
import org.opengrok.indexer.analysis.NullableNumLinesLOC;
import org.opengrok.indexer.configuration.PathAccepter;
import org.opengrok.indexer.configuration.RuntimeEnvironment;
import org.opengrok.indexer.history.CacheException;
import org.opengrok.indexer.history.HistoryGuru;
import org.opengrok.indexer.logger.LoggerFactory;
import org.opengrok.indexer.search.DirectoryEntry;
import org.opengrok.indexer.web.EftarFileReader;
import org.opengrok.indexer.web.Util;

/**
 * Generates HTML listing of a Directory.
 */
public class DirectoryListing {
    private static final Logger LOGGER = LoggerFactory.getLogger(DirectoryListing.class);
    protected static final String TD_END_TAG = "</td>";

    protected static final String BLANK_PLACEHOLDER = "-";
    private final EftarFileReader desc;
    private final long now;

    public DirectoryListing() {
        desc = null;
        now = System.currentTimeMillis();
    }

    public DirectoryListing(EftarFileReader desc) {
        this.desc = desc;
        now = System.currentTimeMillis();
    }

    /**
     * Write part of HTML code which contains file/directory last modification time and size.
     * The size printed for directories will be always {@link #BLANK_PLACEHOLDER}.
     * The time printed will be string representation of the non {@code null} time or {@link #BLANK_PLACEHOLDER}.
     * @param out write destination
     * @param file the file or directory to use for writing the data
     * @param date the time of the last commit that touched {@code file} or {@code null} if unknown
     * @param dateFormatter the formatter to use for pretty printing dates
     *
     * @throws IOException when writing to the {@code out} parameter failed
     */
    public void printDateSize(Writer out, File file, Date date, Format dateFormatter) throws IOException {
        out.write("<td>");
        if (date == null) {
            out.write(BLANK_PLACEHOLDER);
        } else {
            long lastModTime = date.getTime();
            if (now - lastModTime < 86400000) {
                out.write("Today");
            } else {
                out.write(dateFormatter.format(date));
            }
        }
        out.write("</td><td>");
        if (file.isDirectory()) {
            out.write(BLANK_PLACEHOLDER);
        } else {
            out.write(Util.readableSize(file.length()));
        }
        out.write(TD_END_TAG);
    }

    /**
     * Traverse directory until subdirectory with more than one item
     * (other than directory) or end of path is reached.
     * @param dir directory to traverse
     * @return string representing path with empty directories or the name of the directory
     */
    private static String getSimplifiedPath(File dir) {
        String[] files = dir.list();

        // Permissions can prevent getting list of items in the directory.
        if (files == null) {
            return dir.getName();
        }

        if (files.length == 1) {
            File entry = new File(dir, files[0]);
            PathAccepter pathAccepter = RuntimeEnvironment.getInstance().getPathAccepter();
            if (pathAccepter.accept(entry) && entry.isDirectory()) {
                return (dir.getName() + "/" + getSimplifiedPath(entry));
            }
        }

        return dir.getName();
    }

    /**
     * Calls
     * {@link #extraListTo(java.lang.String, java.io.File, java.io.Writer, java.lang.String, java.util.List)}
     * with {@code contextPath}, {@code dir}, {@code out}, {@code path},
     * and a list mapped from {@code files}.
     * @param contextPath context path
     * @param dir directory
     * @param out writer
     * @param path path
     * @param files list of files
     * @throws CacheException on error
     * @throws IOException I/O exception
     */
    @VisibleForTesting
    public void listTo(String contextPath, File dir, Writer out, String path, List<String> files)
            throws IOException, CacheException {

        List<DirectoryEntry> filesExtra = createDirectoryEntries(dir, path, files);
        extraListTo(contextPath, dir, out, path, filesExtra);
    }

    /**
     * @param dir the directory to list
     * @param path virtual path of the directory (usually the path name of
     *        <var>dir</var> with the source root directory stripped off).
     * @param files list of file paths
     * @return list of {@link DirectoryEntry} instances, filtered via {@link PathAccepter}
     * @throws CacheException if history cache operation failed
     */
    public List<DirectoryEntry> createDirectoryEntries(File dir, String path, List<String> files) throws CacheException {
        List<DirectoryEntry> entries = new ArrayList<>(files.size());

        for (String filePath : files) {
            File file = new File(dir, filePath);
            DirectoryEntry entry = new DirectoryEntry(file);
            entries.add(entry);
        }

        // Filter out entries that are not allowed.
        PathAccepter pathAccepter = RuntimeEnvironment.getInstance().getPathAccepter();
        entries.removeIf(entry -> !pathAccepter.accept(entry.getFile()));

        if (entries.isEmpty()) {
            return entries;
        }

        int offset = -1;
        EftarFileReader.FNode parentFNode = null;
        if (desc != null) {
            try {
                parentFNode = desc.getNode(path);
            } catch (IOException e) {
                LOGGER.log(Level.WARNING, String.format("cannot get Eftar node for path ''%s''", path), e);
            }
            if (parentFNode != null) {
                offset = parentFNode.getChildOffset();
            }
        }

        boolean fallback = HistoryGuru.getInstance().fillLastHistoryEntries(dir, entries);

        for (DirectoryEntry entry : entries) {
            File child = entry.getFile();
            String filename = child.getName();

            String pathDescription = "";
            try {
                if (offset > 0) {
                    pathDescription = desc.getChildTag(parentFNode, filename);
                }
            } catch (IOException e) {
                LOGGER.log(Level.WARNING, String.format("cannot get path description for '%s'", child), e);
            }
            entry.setPathDescription(pathDescription);

            if (entry.getDate() == null && fallback) {
                long date = child.lastModified();
                entry.setDate(new Date(date));
            }
        }

        return entries;
    }

    /**
     * Write HTML-ized listing of the given directory to the given destination.
     *
     * @param contextPath path used for link prefixes
     * @param dir the directory to list
     * @param out write destination
     * @param path virtual path of the directory (usually the path name of
     *  <var>dir</var> with the source root directory stripped off).
     * @param entries basenames of potential children of the directory to list,
     *  assuming that these were filtered by {@link PathAccepter}.
     * @throws IOException when cannot write to the {@code out} parameter
     */
    public void extraListTo(String contextPath, File dir, Writer out,
                                    String path, @Nullable List<DirectoryEntry> entries) throws IOException {
        // TODO this belongs to a jsp, not here
        var dateFormatter = new SimpleDateFormat("dd-MMM-yyyy", Locale.getDefault());

        out.write("<table id=\"dirlist\" class=\"tablesorter tablesorter-default\">\n");
        out.write("<thead>\n");
        out.write("<tr>\n");
        out.write("<th class=\"sorter-false\"></th>\n");
        out.write("<th>Name</th>\n");
        out.write("<th class=\"sorter-false\"></th>\n");
        out.write("<th class=\"sort-dates\">Date</th>\n");
        out.write("<th class=\"sort-groksizes\">Size</th>\n");
        out.write("<th>#Lines</th>\n");
        out.write("<th>LOC</th>\n");
        var strPathDescriptionsHeader = Optional.ofNullable(entries)
                .stream()
                .flatMap(List::stream)
                .map(DirectoryEntry::getPathDescription)
                .filter(Objects::nonNull)
                .filter(pathDescription -> !pathDescription.isEmpty())
                .findAny()
                .map(pathDescription -> "<th><samp>Description</samp></th>\n")
                .orElse("");
        out.write(strPathDescriptionsHeader);
        out.write("</tr>\n</thead>\n<tbody>\n");


        // Print the '..' entry even for empty directories.
        if (!path.isEmpty()) {
            out.write("<tr><td><p class=\"'r'\"/></td><td>");
            out.write("<b><a href=\"..\">..</a></b></td><td></td>");
            printDateSize(out, dir.getParentFile(), null, dateFormatter);
            out.write("</tr>\n");
        }

        if (entries != null) {
            for (DirectoryEntry entry : entries) {
                printDirectoryEntry(contextPath, out, path, entry, dateFormatter);
            }
        }
        out.write("</tbody>\n</table>");
    }
    private void printDirectoryEntry(String contextPath, Writer out,
                                       String path, DirectoryEntry entry,
                                     Format dateFormatter) throws IOException {
        File child = entry.getFile();
        String filename = child.getName();

        boolean isDir = child.isDirectory();

        out.write("<tr><td>");
        out.write("<p class=\"");
        out.write(isDir ? 'r' : 'p');
        out.write("\"/>");
        out.write("</td><td><a href=\"");
        if (isDir) {
            String longpath = getSimplifiedPath(child);
            out.write(Util.uriEncodePath(longpath));
            out.write("/\"><b>");
            int idx;
            if ((idx = longpath.lastIndexOf('/')) > 0) {
                out.write("<span class=\"simplified-path\">");
                out.write(longpath.substring(0, idx + 1));
                out.write("</span>");
                out.write(longpath.substring(idx + 1));
            } else {
                out.write(longpath);
            }
            out.write("</b></a>/");
        } else {
            out.write(Util.uriEncodePath(filename));
            out.write("\"");
            if (entry.getDescription() != null) {
                out.write(" class=\"title-tooltip\"");
                out.write(" title=\"");
                out.write(Util.encode(entry.getDescription()));
                out.write("\"");
            }
            out.write(">");
            out.write(filename);
            out.write("</a>");
        }
        out.write(TD_END_TAG);
        Util.writeHAD(out, contextPath, path + filename);
        printDateSize(out, child, entry.getDate(), dateFormatter);
        printNumlines(out, entry, isDir);
        printLoc(out, entry, isDir);
        var strPathDescription = Optional.ofNullable(entry.getPathDescription())
                .filter(pathDescription -> !pathDescription.isEmpty())
                .map(pathDescription -> "<td>" + pathDescription + TD_END_TAG)
                .orElse("");
        out.write(strPathDescription);
        out.write("</tr>\n");
    }
    private void printNumlines(Writer out, DirectoryEntry entry, boolean isDir)
            throws IOException {
        Long numlines = null;
        String readableNumlines = "";
        NullableNumLinesLOC extra = entry.getExtra();
        if (extra != null) {
            numlines = extra.getNumLines();
        }
        if (numlines != null) {
            readableNumlines = Util.readableCount(numlines, isDir);
        }

        out.write("<td class=\"numlines\">");
        out.write(readableNumlines);
        out.write(TD_END_TAG);
    }

    private void printLoc(Writer out, DirectoryEntry entry, boolean isDir)
            throws IOException {
        Long loc = null;
        String readableLoc = "";
        NullableNumLinesLOC extra = entry.getExtra();
        if (extra != null) {
            loc = extra.getLOC();
        }
        if (loc != null) {
            readableLoc = Util.readableCount(loc, isDir);
        }

        out.write("<td class=\"loc\">");
        out.write(readableLoc);
        out.write(TD_END_TAG);
    }
}

1	/*
2	* CDDL HEADER START
3	*
4	* The contents of this file are subject to the terms of the
5	* Common Development and Distribution License (the "License").
6	* You may not use this file except in compliance with the License.
7	*
8	* See LICENSE.txt included in this distribution for the specific
9	* language governing permissions and limitations under the License.
10	*
11	* When distributing Covered Code, include this CDDL HEADER in each
12	* file and include the License file at LICENSE.txt.
13	* If applicable, add the following below this CDDL HEADER, with the
14	* fields enclosed by brackets "[]" replaced with your own identifying
15	* information: Portions Copyright [yyyy] [name of copyright owner]
16	*
17	* CDDL HEADER END
18	*/
19
20	/*
21	* Copyright (c) 2005, 2022, Oracle and/or its affiliates. All rights reserved.
22	* Portions Copyright (c) 2011, Jens Elkner.
23	* Portions Copyright (c) 2017, 2020, Chris Fraire <cfraire@me.com>.
24	*/
25	package org.opengrok.web;
26
27	import java.io.File;
28	import java.io.IOException;
29	import java.io.Writer;
30	import java.text.Format;
31	import java.text.SimpleDateFormat;
32	import java.util.ArrayList;
33	import java.util.Date;
34	import java.util.List;
35	import java.util.Locale;
36	import java.util.Objects;
37	import java.util.Optional;
38	import java.util.logging.Level;
39	import java.util.logging.Logger;
40
41	import org.jetbrains.annotations.Nullable;
42	import org.jetbrains.annotations.VisibleForTesting;
43	import org.opengrok.indexer.analysis.NullableNumLinesLOC;
44	import org.opengrok.indexer.configuration.PathAccepter;
45	import org.opengrok.indexer.configuration.RuntimeEnvironment;
46	import org.opengrok.indexer.history.CacheException;
47	import org.opengrok.indexer.history.HistoryGuru;
48	import org.opengrok.indexer.logger.LoggerFactory;
49	import org.opengrok.indexer.search.DirectoryEntry;
50	import org.opengrok.indexer.web.EftarFileReader;
51	import org.opengrok.indexer.web.Util;
52
53	/**
54	* Generates HTML listing of a Directory.
55	*/
56	public class DirectoryListing {
57	private static final Logger LOGGER = LoggerFactory.getLogger(DirectoryListing.class);	1✔
58	protected static final String TD_END_TAG = "</td>";
59
60	protected static final String BLANK_PLACEHOLDER = "-";
61	private final EftarFileReader desc;
62	private final long now;
63
64	public DirectoryListing() {	1✔
65	desc = null;	1✔
66	now = System.currentTimeMillis();	1✔
67	}	1✔
68
69	public DirectoryListing(EftarFileReader desc) {	1✔
70	this.desc = desc;	1✔
71	now = System.currentTimeMillis();	1✔
72	}	1✔
73
74	/**
75	* Write part of HTML code which contains file/directory last modification time and size.
76	* The size printed for directories will be always {@link #BLANK_PLACEHOLDER}.
77	* The time printed will be string representation of the non {@code null} time or {@link #BLANK_PLACEHOLDER}.
78	* @param out write destination
79	* @param file the file or directory to use for writing the data
80	* @param date the time of the last commit that touched {@code file} or {@code null} if unknown
81	* @param dateFormatter the formatter to use for pretty printing dates
82	*
83	* @throws IOException when writing to the {@code out} parameter failed
84	*/
85	public void printDateSize(Writer out, File file, Date date, Format dateFormatter) throws IOException {
86	out.write("<td>");	1✔
87	if (date == null) {	1✔
88	out.write(BLANK_PLACEHOLDER);	1✔
89	} else {
90	long lastModTime = date.getTime();	1✔
91	if (now - lastModTime < 86400000) {	1✔
92	out.write("Today");	1✔
93	} else {
94	out.write(dateFormatter.format(date));	1✔
95	}
96	}
97	out.write("</td><td>");	1✔
98	if (file.isDirectory()) {	1✔
99	out.write(BLANK_PLACEHOLDER);	1✔
100	} else {
101	out.write(Util.readableSize(file.length()));	1✔
102	}
103	out.write(TD_END_TAG);	1✔
104	}	1✔
105
106	/**
107	* Traverse directory until subdirectory with more than one item
108	* (other than directory) or end of path is reached.
109	* @param dir directory to traverse
110	* @return string representing path with empty directories or the name of the directory
111	*/
112	private static String getSimplifiedPath(File dir) {
113	String[] files = dir.list();	1✔
114
115	// Permissions can prevent getting list of items in the directory.
116	if (files == null) {	1✔
117	return dir.getName();	×
118	}
119
120	if (files.length == 1) {	1✔
121	File entry = new File(dir, files[0]);	1✔
122	PathAccepter pathAccepter = RuntimeEnvironment.getInstance().getPathAccepter();	1✔
123	if (pathAccepter.accept(entry) && entry.isDirectory()) {	1✔
124	return (dir.getName() + "/" + getSimplifiedPath(entry));	×
125	}
126	}
127
128	return dir.getName();	1✔
129	}
130
131	/**
132	* Calls
133	* {@link #extraListTo(java.lang.String, java.io.File, java.io.Writer, java.lang.String, java.util.List)}
134	* with {@code contextPath}, {@code dir}, {@code out}, {@code path},
135	* and a list mapped from {@code files}.
136	* @param contextPath context path
137	* @param dir directory
138	* @param out writer
139	* @param path path
140	* @param files list of files
141	* @throws CacheException on error
142	* @throws IOException I/O exception
143	*/
144	@VisibleForTesting
145	public void listTo(String contextPath, File dir, Writer out, String path, List<String> files)
146	throws IOException, CacheException {
147
148	List<DirectoryEntry> filesExtra = createDirectoryEntries(dir, path, files);	1✔
149	extraListTo(contextPath, dir, out, path, filesExtra);	1✔
150	}	1✔
151
152	/**
153	* @param dir the directory to list
154	* @param path virtual path of the directory (usually the path name of
155	* <var>dir</var> with the source root directory stripped off).
156	* @param files list of file paths
157	* @return list of {@link DirectoryEntry} instances, filtered via {@link PathAccepter}
158	* @throws CacheException if history cache operation failed
159	*/
160	public List<DirectoryEntry> createDirectoryEntries(File dir, String path, List<String> files) throws CacheException {
161	List<DirectoryEntry> entries = new ArrayList<>(files.size());	1✔
162
163	for (String filePath : files) {	1✔
164	File file = new File(dir, filePath);	1✔
165	DirectoryEntry entry = new DirectoryEntry(file);	1✔
166	entries.add(entry);	1✔
167	}	1✔
168
169	// Filter out entries that are not allowed.
170	PathAccepter pathAccepter = RuntimeEnvironment.getInstance().getPathAccepter();	1✔
171	entries.removeIf(entry -> !pathAccepter.accept(entry.getFile()));	1✔
172
173	if (entries.isEmpty()) {	1✔
174	return entries;	×
175	}
176
177	int offset = -1;	1✔
178	EftarFileReader.FNode parentFNode = null;	1✔
179	if (desc != null) {	1✔
180	try {
181	parentFNode = desc.getNode(path);	1✔
182	} catch (IOException e) {	×
183	LOGGER.log(Level.WARNING, String.format("cannot get Eftar node for path ''%s''", path), e);	×
184	}	1✔
185	if (parentFNode != null) {	1✔
186	offset = parentFNode.getChildOffset();	1✔
187	}
188	}
189
190	boolean fallback = HistoryGuru.getInstance().fillLastHistoryEntries(dir, entries);	1✔
191
192	for (DirectoryEntry entry : entries) {	1✔
193	File child = entry.getFile();	1✔
194	String filename = child.getName();	1✔
195
196	String pathDescription = "";	1✔
197	try {
198	if (offset > 0) {	1✔
199	pathDescription = desc.getChildTag(parentFNode, filename);	1✔
200	}
201	} catch (IOException e) {	×
202	LOGGER.log(Level.WARNING, String.format("cannot get path description for '%s'", child), e);	×
203	}	1✔
204	entry.setPathDescription(pathDescription);	1✔
205
206	if (entry.getDate() == null && fallback) {	1✔
207	long date = child.lastModified();	1✔
208	entry.setDate(new Date(date));	1✔
209	}
210	}	1✔
211
212	return entries;	1✔
213	}
214
215	/**
216	* Write HTML-ized listing of the given directory to the given destination.
217	*
218	* @param contextPath path used for link prefixes
219	* @param dir the directory to list
220	* @param out write destination
221	* @param path virtual path of the directory (usually the path name of
222	* <var>dir</var> with the source root directory stripped off).
223	* @param entries basenames of potential children of the directory to list,
224	* assuming that these were filtered by {@link PathAccepter}.
225	* @throws IOException when cannot write to the {@code out} parameter
226	*/
227	public void extraListTo(String contextPath, File dir, Writer out,
228	String path, @Nullable List<DirectoryEntry> entries) throws IOException {
229	// TODO this belongs to a jsp, not here
230	var dateFormatter = new SimpleDateFormat("dd-MMM-yyyy", Locale.getDefault());	1✔
231
232	out.write("<table id=\"dirlist\" class=\"tablesorter tablesorter-default\">\n");	1✔
233	out.write("<thead>\n");	1✔
234	out.write("<tr>\n");	1✔
235	out.write("<th class=\"sorter-false\"></th>\n");	1✔
236	out.write("<th>Name</th>\n");	1✔
237	out.write("<th class=\"sorter-false\"></th>\n");	1✔
238	out.write("<th class=\"sort-dates\">Date</th>\n");	1✔
239	out.write("<th class=\"sort-groksizes\">Size</th>\n");	1✔
240	out.write("<th>#Lines</th>\n");	1✔
241	out.write("<th>LOC</th>\n");	1✔
242	var strPathDescriptionsHeader = Optional.ofNullable(entries)	1✔
243	.stream()	1✔
244	.flatMap(List::stream)	1✔
245	.map(DirectoryEntry::getPathDescription)	1✔
246	.filter(Objects::nonNull)	1✔
247	.filter(pathDescription -> !pathDescription.isEmpty())	1✔
248	.findAny()	1✔
249	.map(pathDescription -> "<th><samp>Description</samp></th>\n")	1✔
250	.orElse("");	1✔
251	out.write(strPathDescriptionsHeader);	1✔
252	out.write("</tr>\n</thead>\n<tbody>\n");	1✔
253
254
255	// Print the '..' entry even for empty directories.
256	if (!path.isEmpty()) {	1✔
257	out.write("<tr><td><p class=\"'r'\"/></td><td>");	1✔
258	out.write("<b><a href=\"..\">..</a></b></td><td></td>");	1✔
259	printDateSize(out, dir.getParentFile(), null, dateFormatter);	1✔
260	out.write("</tr>\n");	1✔
261	}
262
263	if (entries != null) {	1✔
264	for (DirectoryEntry entry : entries) {	1✔
265	printDirectoryEntry(contextPath, out, path, entry, dateFormatter);	1✔
266	}	1✔
267	}
268	out.write("</tbody>\n</table>");	1✔
269	}	1✔
270	private void printDirectoryEntry(String contextPath, Writer out,
271	String path, DirectoryEntry entry,
272	Format dateFormatter) throws IOException {
273	File child = entry.getFile();	1✔
274	String filename = child.getName();	1✔
275
276	boolean isDir = child.isDirectory();	1✔
277
278	out.write("<tr><td>");	1✔
279	out.write("<p class=\"");	1✔
280	out.write(isDir ? 'r' : 'p');	1✔
281	out.write("\"/>");	1✔
282	out.write("</td><td><a href=\"");	1✔
283	if (isDir) {	1✔
284	String longpath = getSimplifiedPath(child);	1✔
285	out.write(Util.uriEncodePath(longpath));	1✔
286	out.write("/\"><b>");	1✔
287	int idx;
288	if ((idx = longpath.lastIndexOf('/')) > 0) {	1✔
289	out.write("<span class=\"simplified-path\">");	×
290	out.write(longpath.substring(0, idx + 1));	×
291	out.write("</span>");	×
292	out.write(longpath.substring(idx + 1));	×
293	} else {
294	out.write(longpath);	1✔
295	}
296	out.write("</b></a>/");	1✔
297	} else {	1✔
298	out.write(Util.uriEncodePath(filename));	1✔
299	out.write("\"");	1✔
300	if (entry.getDescription() != null) {	1✔
301	out.write(" class=\"title-tooltip\"");	1✔
302	out.write(" title=\"");	1✔
303	out.write(Util.encode(entry.getDescription()));	1✔
304	out.write("\"");	1✔
305	}
306	out.write(">");	1✔
307	out.write(filename);	1✔
308	out.write("</a>");	1✔
309	}
310	out.write(TD_END_TAG);	1✔
311	Util.writeHAD(out, contextPath, path + filename);	1✔
312	printDateSize(out, child, entry.getDate(), dateFormatter);	1✔
313	printNumlines(out, entry, isDir);	1✔
314	printLoc(out, entry, isDir);	1✔
315	var strPathDescription = Optional.ofNullable(entry.getPathDescription())	1✔
316	.filter(pathDescription -> !pathDescription.isEmpty())	1✔
317	.map(pathDescription -> "<td>" + pathDescription + TD_END_TAG)	1✔
318	.orElse("");	1✔
319	out.write(strPathDescription);	1✔
320	out.write("</tr>\n");	1✔
321	}	1✔
322	private void printNumlines(Writer out, DirectoryEntry entry, boolean isDir)
323	throws IOException {
324	Long numlines = null;	1✔
325	String readableNumlines = "";	1✔
326	NullableNumLinesLOC extra = entry.getExtra();	1✔
327	if (extra != null) {	1✔
328	numlines = extra.getNumLines();	×
329	}
330	if (numlines != null) {	1✔
331	readableNumlines = Util.readableCount(numlines, isDir);	×
332	}
333
334	out.write("<td class=\"numlines\">");	1✔
335	out.write(readableNumlines);	1✔
336	out.write(TD_END_TAG);	1✔
337	}	1✔
338
339	private void printLoc(Writer out, DirectoryEntry entry, boolean isDir)
340	throws IOException {
341	Long loc = null;	1✔
342	String readableLoc = "";	1✔
343	NullableNumLinesLOC extra = entry.getExtra();	1✔
344	if (extra != null) {	1✔
345	loc = extra.getLOC();	×
346	}
347	if (loc != null) {	1✔
348	readableLoc = Util.readableCount(loc, isDir);	×
349	}
350
351	out.write("<td class=\"loc\">");	1✔
352	out.write(readableLoc);	1✔
353	out.write(TD_END_TAG);	1✔
354	}	1✔
355	}

oracle / opengrok / #3642

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