DiffService.java

Go to the documentation of this file.

/*
 * Autopsy Forensic Browser
 *
 * Copyright 2020 Basis Technology Corp.
 * Contact: carrier <at> sleuthkit <dot> org
 *
 * 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
 *
 *     http://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 org.sleuthkit.autopsy.integrationtesting;
 
import com.github.difflib.DiffUtils;
import com.github.difflib.patch.AbstractDelta;
import com.github.difflib.patch.Chunk;
import com.github.difflib.patch.Patch;
import java.io.File;
import java.io.IOException;
import java.nio.file.Files;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
import java.util.stream.Stream;
import org.apache.commons.io.FileUtils;
import org.apache.commons.lang3.StringUtils;
import org.apache.commons.lang3.exception.ExceptionUtils;
import org.apache.commons.lang3.tuple.Pair;

public class DiffService {

    public static class DiffServiceException extends Exception {
 
        private static final long serialVersionUID = 1L;

        DiffServiceException(String message) {
            super(message);
        }

        DiffServiceException(String message, Throwable exception) {
            super(message, exception);
        }
    }
 
    private static final String ORIG_LINE_PREFIX = "< ";
    private static final String CUR_LINE_PREFIX = "> ";
    private static final String[] DIFF_BREAK = new String[]{"", "", ""};
    private static final String[] FILE_DIFF_BREAK = new String[]{"", "", "", ""};
    private static final String NEW_LINE = System.getProperty("line.separator");

    String diffFilesOrDirs(File prevResult, File curResult) throws DiffServiceException {
        if (prevResult.isDirectory() && curResult.isDirectory()) {
            final Map<String, File> prevFiles = FileUtils.listFiles(prevResult, null, true).stream()
                    .collect(Collectors.toMap(f -> getRelative(prevResult, f), f -> f, (f1, f2) -> f1));
 
            final Map<String, File> curFiles = FileUtils.listFiles(curResult, null, true).stream()
                    .collect(Collectors.toMap(f -> getRelative(curResult, f), f -> f, (f1, f2) -> f1));
 
            Map<String, Pair<File, File>> prevCurMapping = Stream.of(prevFiles, curFiles)
                    .flatMap((map) -> map.keySet().stream())
                    .collect(Collectors.toMap(k -> k, k -> Pair.of(prevFiles.get(k), curFiles.get(k)), (v1, v2) -> v1));
 
            String fullDiff = prevCurMapping.entrySet().stream()
                    .map((entry) -> getFileDiffs(entry.getValue().getLeft(), entry.getValue().getRight(), entry.getKey()))
                    .filter((val) -> val != null)
                    .collect(Collectors.joining(String.join(NEW_LINE, FILE_DIFF_BREAK)));
 
            return fullDiff;
 
        } else if (prevResult.isFile() && curResult.isFile()) {
            return getFileDiffs(prevResult, curResult, prevResult.toString() + " / " + curResult.toString());
 
        } else {
            throw new DiffServiceException(String.format("%s and %s must be of same type (directory/file).", prevResult.toString(), curResult.toString()));
        }
    }

    private String getFileDiffs(File orig, File cur, String identifier) {
        boolean hasOrig = (orig != null && orig.exists());
        boolean hasCur = (cur != null && cur.exists());
        if (!hasOrig && !hasCur) {
            return null;
        } else if (!hasOrig && hasCur) {
            return getHeaderWithDivider("ADDITIONAL FILE IN CURRENT: " + identifier);
        } else if (hasOrig && !hasCur) {
            return getHeaderWithDivider("MISSING FILE IN CURRENT: " + identifier);
        } else {
            try {
                return diffLines(Files.readAllLines(orig.toPath()), Files.readAllLines(cur.toPath()), getHeaderWithDivider(identifier + ":"));
            } catch (IOException ex) {
                return getHeaderWithDivider(String.format("ERROR reading files at %s / %s %s%s",
                        orig.toString(), cur.toString(), NEW_LINE, ExceptionUtils.getStackTrace(ex)));
            }
        }
    }
 
    private String getChunkLineNumString(Chunk<?> chunk) {
        return String.format("%d,%d", chunk.getPosition() + 1, chunk.getLines().size());
    }

    private String getDiffLineNumString(Chunk<?> orig, Chunk<?> cur) {
        return String.format("-%s +%s", getChunkLineNumString(orig), getChunkLineNumString(cur));
    }

    private List<String> getLinesDiff(Chunk<String> orig, Chunk<String> cur) {
        Stream<String> origPrefixed = orig.getLines().stream()
                .map((line) -> ORIG_LINE_PREFIX + line);
 
        Stream<String> curPrefixed = cur.getLines().stream()
                .map((line) -> CUR_LINE_PREFIX + line);
 
        return Stream.concat(origPrefixed, curPrefixed)
                .collect(Collectors.toList());
    }
 
    private String getLinesDiffString(AbstractDelta<String> delta) {
        String lineNums = getDiffLineNumString(delta.getSource(), delta.getTarget());
        List<String> linesDiff = getLinesDiff(delta.getSource(), delta.getTarget());
 
        return Stream.concat(Stream.of(lineNums), linesDiff.stream())
                .collect(Collectors.joining(NEW_LINE)) + NEW_LINE;
    }

    private String diffLines(List<String> orig, List<String> cur, String header) {
        //compute the patch: this is the diffutils part
        Patch<String> patch = DiffUtils.diff(orig, cur);
 
        String diff = patch.getDeltas().stream()
                .map(delta -> getLinesDiffString(delta))
                .collect(Collectors.joining(String.join(NEW_LINE, DIFF_BREAK)));
 
        if (StringUtils.isBlank(diff)) {
            return null;
        }
 
        return (header != null)
                ? header + NEW_LINE + diff
                : diff;
    }
 
    private String getHeaderWithDivider(String remark) {
        String divider = "-----------------------------------------------------------";
        return String.join(NEW_LINE, divider, remark, divider);
    }
 
    private String getRelative(File rootDirectory, File file) {
        return rootDirectory.toURI().relativize(file.toURI()).getPath();
    }
}