TreeDiff v1.0: Added filtering options and GUI stub.

build.gradle

@@ -1,15 +1,17 @@
 apply plugin: "groovy"
+apply plugin: "application"
 apply plugin: "maven"
 
 group = "com.jdblabs"
-version = "alpha.0"
+version = "1.0"
+mainClassName = "com.jdblabs.file.treediff.TreeDiff"
 
 repositories {
     mavenLocal()
     mavenCentral() }
 
 dependencies {
-    compile 'org.codehaus.groovy:groovy-all:2.3.6'
+    compile 'org.codehaus.groovy:groovy-all:2.4.3'
     compile 'org.slf4j:slf4j-api:1.7.10'
     compile 'ch.qos.logback:logback-core:1.1.2'
     compile 'ch.qos.logback:logback-classic:1.1.2'

src/main/groovy/com/jdblabs/file/treedif/DirAnalysis.groovy

@@ -0,0 +1,9 @@
+package com.jdblabs.file.treediff
+
+public class DirAnalysis {
+    List<FileEntry> allEntries = [];
+    Map<String, FileEntry> byRelativePath = [:]
+    Map<String, List<FileEntry> > byChecksum = [:]
+}
+
+

src/main/groovy/com/jdblabs/file/treedif/FileEntry.groovy

@@ -0,0 +1,15 @@
+package com.jdblabs.file.treediff
+
+public class FileEntry {
+    File file
+    String relativePath
+    String checksum
+
+    public boolean equals(Object that) {
+        if (that == null) return falase
+        if (!(that instanceof FileEntry)) return false
+
+
+        return this.relativePath == that.relativePath &&
+               this.checksum == that.checksum; }
+}

src/main/groovy/com/jdblabs/file/treedif/TreeDiff.groovy

@@ -1,65 +1,117 @@
-package com.jdblabs.file
+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 = "alpha.0";
+    public static final String VERSION = "1.0";
 
     private ObjectMapper objectMapper 
 
     public static void main(String[] args) {
 
-        def cli = [
+        def cliDef = [
             'h': [longName: 'help'],
-            'v': [longName: 'version']/*,
+            'v': [longName: 'version'],
+            'g': [longName: 'gui'],
             'i': [longName: 'analysis-in'],
-            'o': [longName: 'analysis-out']*/
+            '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(cli, args)
+        def opts = LightOptionParser.parseOptions(cliDef, args)
 
         if (opts.h) { /* TODO */ return }
 
-        if (opts.v) { println "JDB Labs TreeDiff v${VERSION}" }
+        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 leftRoot = new File(opts.args[0])
-        File rightRoot = new File(opts.args[1])
 
-        if (!leftRoot.exists() || !leftRoot.isDirectory()) {
+        File rootDir, leftDir, rightDir
-            println "TreeDiff v${VERSION}: '${args[0]}' cannot be found or is not a directory"
+
+        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 (!rightRoot.exists() || !rightRoot.isDirectory()) {
+        if (!rightDir.exists() || !rightDir.isDirectory()) {
-            println "TreeDiff v${VERSION}: '${args[1]}' cannot be found or is not a directory"
+            println "TreeDiff v${VERSION}: '${opts.args[1]}' cannot be found or is not a directory"
             System.exit(2) }
 
-        DirAnalysis left = analyzeDir(leftRoot)
+        DirAnalysis left = analyzeDir(leftDir)
-        DirAnalysis right = analyzeDir(rightRoot)
+        DirAnalysis right = analyzeDir(rightDir)
 
-        same(left, right).each {
+        if (show.same) same(left, right).each {
-            //       012345678
             println "same:  ${it.relativePath}" }
 
-        samePathDifferentContents(left, right).each {
+        if (show.content) samePathDifferentContents(left, right).each {
             println "contents differ:  $it" }
 
-        sameContentsDifferentPaths(left, right).each {
+        if (show.path) sameContentsDifferentPaths(left, right).each {
-            println "paths differ: ${it.left.relativePath} ${it.right.relativePath}" }
+            println "paths differ: ${it.first.relativePath} ${it.second.relativePath}" }
 
-        firstSideOnly(left, right).each {
+        if (show.left) firstSideOnly(left, right).each {
             println "left only:  ${it.relativePath}" }
 
-        firstSideOnly(right, left).each {
+        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) {
@@ -74,13 +126,13 @@ public class TreeDiff {
             return match != null && l.checksum != match.checksum }
             .collect { it.relativePath } }
 
-    public static List<FileEntryPair> sameContentsDifferentPaths(DirAnalysis left, DirAnalysis right) {
+    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 FileEntryPair(left: l, right: r) }) }
+                    .collect { r -> new Tuple2<FileEntry, FileEntry>(l, r) }) }
-            return acc }.sort { it.left.checksum }
+            return acc }.sort { it.first.checksum }
     }
 
     public static List<FileEntry> firstSideOnly(DirAnalysis first, DirAnalysis second) {
@@ -107,31 +159,6 @@ public class TreeDiff {
         return analysis
     }
 
-    public static class DirAnalysis {
-        List<FileEntry> allEntries = [];
-        Map<String, FileEntry> byRelativePath = [:]
-        Map<String, List<FileEntry> > byChecksum = [:]
-    }
-
-    public static class FileEntry {
-        File file
-        String relativePath
-        String checksum
-
-        public boolean equals(Object that) {
-            if (that == null) return falase
-            if (!(that instanceof FileEntry)) return false
-
-
-            return this.relativePath == that.relativePath &&
-                   this.checksum == that.checksum; }
-    }
-
-    public static class FileEntryPair {
-        FileEntry left;
-        FileEntry right;
-    }
-
     /** #### `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