186 lines
7.1 KiB
Groovy
186 lines
7.1 KiB
Groovy
package com.jdblabs.file.treediff
|
|
|
|
import groovy.io.FileType
|
|
import groovy.swing.SwingBuilder
|
|
import com.jdbernard.util.LightOptionParser
|
|
import org.apache.commons.codec.digest.DigestUtils
|
|
import com.fasterxml.jackson.databind.ObjectMapper
|
|
|
|
public class TreeDiff {
|
|
|
|
public static final String VERSION = "1.0";
|
|
|
|
private ObjectMapper objectMapper
|
|
|
|
public static void main(String[] args) {
|
|
|
|
def cliDef = [
|
|
'h': [longName: 'help'],
|
|
'v': [longName: 'version'],
|
|
'g': [longName: 'gui'],
|
|
'i': [longName: 'analysis-in'],
|
|
'o': [longName: 'analysis-out'],
|
|
's': [longName: 'same'],
|
|
'S': [longName: 'exclude-same'],
|
|
'c': [longName: 'content-mismatch'],
|
|
'C': [longName: 'exclude-content-mismatch'],
|
|
'p': [longName: 'path-mismatch'],
|
|
'P': [longName: 'exclude-path-mismatch'],
|
|
'l': [longName: 'left-only'],
|
|
'L': [longName: 'exclude-left-only'],
|
|
'r': [longName: 'right-only'],
|
|
'R': [longName: 'exclude-right-only'],
|
|
'rd': [longName: 'directory', arguments: 1]
|
|
]
|
|
|
|
def opts = LightOptionParser.parseOptions(cliDef, args)
|
|
|
|
if (opts.h) { /* TODO */ return }
|
|
|
|
if (opts.v) {
|
|
println "JDB Labs TreeDiff v${VERSION}"
|
|
return }
|
|
|
|
if (opts.g) { gui(opts) }
|
|
else cli(opts)
|
|
}
|
|
|
|
public static void cli(def opts) {
|
|
|
|
def show = [ same: false, content: false, path: false,
|
|
left: false, right: false]
|
|
|
|
// If none of the explicit selectors are given, assume all are expeced.
|
|
if (!opts.s && !opts.c && !opts.p && !opts.l && !opts.r) {
|
|
show = [ same: true, content: true, path: true,
|
|
left: true, right: true] }
|
|
|
|
if (opts.s) show.same = true; if (opts.S) show.same = false
|
|
if (opts.c) show.content = true; if (opts.C) show.content = false
|
|
if (opts.p) show.path = true; if (opts.P) show.path = false
|
|
if (opts.l) show.left = true; if (opts.L) show.left = false
|
|
if (opts.r) show.right = true; if (opts.R) show.right = false
|
|
|
|
if (opts.args.size() < 2) {
|
|
/* TODO: print usage */
|
|
println "TreeDiff v${VERSION}: exactly two directory paths are required to compare."
|
|
System.exit(1) }
|
|
|
|
|
|
File rootDir, leftDir, rightDir
|
|
|
|
if (opts.rd) rootDir = new File(opts.rd[0] ?: '.')
|
|
else rootDir = new File('.')
|
|
|
|
if (opts.args[0].startsWith('/')) leftDir = new File(opts.args[0])
|
|
else leftDir = new File(rootDir, opts.args[0])
|
|
|
|
if (opts.args[1].startsWith('/')) rightDir = new File(opts.args[1])
|
|
else rightDir = new File(rootDir, opts.args[1])
|
|
|
|
if (!leftDir.exists() || !leftDir.isDirectory()) {
|
|
println "TreeDiff v${VERSION}: '${opts.args[0]}' cannot be found or is not a directory"
|
|
System.exit(2) }
|
|
|
|
if (!rightDir.exists() || !rightDir.isDirectory()) {
|
|
println "TreeDiff v${VERSION}: '${opts.args[1]}' cannot be found or is not a directory"
|
|
System.exit(2) }
|
|
|
|
DirAnalysis left = analyzeDir(leftDir)
|
|
DirAnalysis right = analyzeDir(rightDir)
|
|
|
|
if (show.same) same(left, right).each {
|
|
println "same: ${it.relativePath}" }
|
|
|
|
if (show.content) samePathDifferentContents(left, right).each {
|
|
println "contents differ: $it" }
|
|
|
|
if (show.path) sameContentsDifferentPaths(left, right).each {
|
|
println "paths differ: ${it.first.relativePath} ${it.second.relativePath}" }
|
|
|
|
if (show.left) firstSideOnly(left, right).each {
|
|
println "left only: ${it.relativePath}" }
|
|
|
|
if (show.right) firstSideOnly(right, left).each {
|
|
println "right only: ${it.relativePath}" }
|
|
|
|
}
|
|
|
|
public static gui(def opts) {
|
|
frame(title: "TreeDif v${VERSION}", show: true) {
|
|
boxLayout()
|
|
|
|
|
|
}
|
|
}
|
|
|
|
public static List<FileEntry> same(DirAnalysis left, DirAnalysis right) {
|
|
return left.allEntries.findAll { l ->
|
|
FileEntry match = right.byRelativePath[l.relativePath]
|
|
return match != null && l.checksum == match.checksum }
|
|
}
|
|
|
|
public static Set<String> samePathDifferentContents(DirAnalysis left, DirAnalysis right) {
|
|
return left.allEntries.findAll { l ->
|
|
FileEntry match = right.byRelativePath[l.relativePath]
|
|
return match != null && l.checksum != match.checksum }
|
|
.collect { it.relativePath } }
|
|
|
|
public static List<Tuple2<FileEntry, FileEntry> > sameContentsDifferentPaths(DirAnalysis left, DirAnalysis right) {
|
|
return left.allEntries.inject([]) { acc, l ->
|
|
List<FileEntry> matches = right.byChecksum[l.checksum]
|
|
if (matches) {
|
|
acc.addAll(matches.findAll { l.relativePath != it.relativePath }
|
|
.collect { r -> new Tuple2<FileEntry, FileEntry>(l, r) }) }
|
|
return acc }.sort { it.first.checksum }
|
|
}
|
|
|
|
public static List<FileEntry> firstSideOnly(DirAnalysis first, DirAnalysis second) {
|
|
return first.allEntries.findAll {
|
|
!second.byRelativePath.containsKey(it.relativePath) &&
|
|
!second.byChecksum.containsKey(it.checksum) } }
|
|
|
|
public static DirAnalysis analyzeDir(File root) {
|
|
DirAnalysis analysis = new DirAnalysis()
|
|
|
|
root.eachFileRecurse(FileType.FILES) { file ->
|
|
FileEntry entry = new FileEntry(
|
|
file: file,
|
|
relativePath: getRelativePath(root, file),
|
|
checksum: file.withInputStream { DigestUtils.md5Hex(it) })
|
|
|
|
analysis.allEntries << entry;
|
|
analysis.byRelativePath[entry.relativePath] = entry
|
|
|
|
if (!analysis.byChecksum.containsKey(entry.checksum)) {
|
|
analysis.byChecksum[entry.checksum] = [] }
|
|
analysis.byChecksum[entry.checksum] << entry }
|
|
|
|
return analysis
|
|
}
|
|
|
|
/** #### `getRelativePath`
|
|
* Given a parent path and a child path, assuming the child path is
|
|
* contained within the parent path, return the relative path from the
|
|
* parent to the child. */
|
|
public static String getRelativePath(File parent, File child) {
|
|
def parentPath = parent.canonicalPath.split("[\\\\/]")
|
|
def childPath = child.canonicalPath.split("[\\\\/]")
|
|
|
|
/// If the parent path is longer it cannot contain the child path and
|
|
/// we cannot construct a relative path without backtracking.
|
|
if (parentPath.length > childPath.length) return ""
|
|
|
|
/// Compare the parent and child path up until the end of the parent
|
|
/// path.
|
|
int b = 0
|
|
while (b < parentPath.length && parentPath[b] == childPath[b] ) b++;
|
|
|
|
/// If we stopped before reaching the end of the parent path it must be
|
|
/// that the paths do not match. The parent cannot contain the child and
|
|
/// we cannot build a relative path without backtracking.
|
|
if (b != parentPath.length) return ""
|
|
return (['.'] + childPath[b..<childPath.length]).join('/') }
|
|
|
|
}
|