Fix a few bugs and add up-to-date check for make patches

Author: stephan-gh

build.gradle

@@ -12,7 +12,7 @@ plugins {
 }
 
 group = 'net.minecrell'
-version = '0.1.1'
+version = '0.2-SNAPSHOT'
 description = 'A Gradle plugin to manage patches for Git repositories'
 
 sourceCompatibility = 1.6

src/main/groovy/net/minecrell/gitpatcher/git/MailPatch.groovy

@@ -55,11 +55,15 @@ class MailPatch {
         return author == commit.authorIdent && message == commit.fullMessage
     }
 
-    static MailPatch parse(InputStream is) {
-        return parse(is.newReader('UTF-8'))
+    static MailPatch parseHeader(byte[] data) {
+        return parseHeader(new ByteArrayInputStream(data))
     }
 
-    static MailPatch parse(BufferedReader reader) {
+    static MailPatch parseHeader(InputStream is) {
+        return parseHeader(is.newReader('UTF-8'))
+    }
+
+    static MailPatch parseHeader(BufferedReader reader) {
         String from = null
         String time = null
         StringBuilder builder = null
@@ -149,25 +153,14 @@ class MailPatch {
 
         def formatter = new DiffFormatter(out)
         formatter.repository = repo
-        formatter.format(commit.getParent(0).tree, commit.tree)
+        try {
+            Patcher.formatPatch(formatter, commit)
+        } finally {
+            formatter.release()
+        }
 
         writer << '-- \n' << JGIT_VERSION << '\n'
         writer.flush()
     }
 
-
-    static String suggestFileName(RevCommit commit, int num) {
-        def result = new StringBuilder(String.format("%04d-", num))
-        for (char c : commit.shortMessage.chars) {
-            if (Character.isLetter(c) || Character.isDigit(c)) {
-                result << c
-            } else if (Character.isWhitespace(c) || c == '/' as char) {
-                result << '-' as char
-            }
-        }
-
-        result << '.patch'
-        return result.toString()
-    }
-
 }

src/main/groovy/net/minecrell/gitpatcher/git/Patcher.groovy

@@ -27,7 +27,10 @@ import static org.eclipse.jgit.revwalk.RevSort.TOPO
 import groovy.transform.stc.ClosureParams
 import groovy.transform.stc.FirstParam
 import groovy.transform.stc.SimpleType
+import org.apache.commons.lang.StringUtils
 import org.eclipse.jgit.api.Git
+import org.eclipse.jgit.diff.DiffFormatter
+import org.eclipse.jgit.revwalk.RevCommit
 import org.eclipse.jgit.revwalk.RevWalk
 
 final class Patcher {
@@ -57,4 +60,28 @@ final class Patcher {
         return walk
     }
 
+    static File[] findPatches(File patchDir) {
+        return patchDir.listFiles({ dir, name ->
+            name.endsWith('.patch') && StringUtils.isNumeric(name.substring(0, 4))
+        } as FilenameFilter).sort()
+    }
+
+    static String suggestFileName(RevCommit commit, int num) {
+        def result = new StringBuilder(String.format("%04d-", num))
+        for (char c : commit.shortMessage.chars) {
+            if (Character.isLetter(c) || Character.isDigit(c)) {
+                result << c
+            } else if (Character.isWhitespace(c) || c == '/' as char) {
+                result << '-' as char
+            }
+        }
+
+        result << '.patch'
+        return result.toString()
+    }
+
+    static void formatPatch(DiffFormatter formatter, RevCommit commit) {
+        formatter.format(commit.getParent(0).tree, commit.tree)
+    }
+
 }

src/main/groovy/net/minecrell/gitpatcher/task/patch/ApplyPatchesTask.groovy

@@ -23,9 +23,11 @@ package net.minecrell.gitpatcher.task.patch
 
 import static net.minecrell.gitpatcher.git.Patcher.withGit
 import static org.eclipse.jgit.api.Git.wrap
+import static org.eclipse.jgit.api.ResetCommand.ResetType.HARD
 import static org.eclipse.jgit.submodule.SubmoduleWalk.getSubmoduleRepository
 
 import net.minecrell.gitpatcher.git.MailPatch
+import net.minecrell.gitpatcher.git.Patcher
 import org.eclipse.jgit.api.Git
 import org.gradle.api.tasks.TaskAction
 
@@ -58,30 +60,35 @@ class ApplyPatchesTask extends PatchTask {
             logger.lifecycle 'Resetting {}...', repo
 
             fetch().setRemote('origin').call()
-            branchCreate()
-                    .setName('master')
-                    .setForce(true)
-                    .setStartPoint('origin/upstream')
-                    .call()
+
+            if (repository.getRef('master') == null) {
+                // Create the master branch
+                branchCreate().setName('master').call()
+            }
+
+            checkout().setName('master').call()
+            reset().setMode(HARD).setRef('origin/upstream').call()
             clean().setCleanDirectories(true).call()
 
-            logger.lifecycle 'Applying patches from {} to {}', patchDir, repo
+            if (patchDir.isDirectory()) {
+                logger.lifecycle 'Applying patches from {} to {}', patchDir, repo
 
-            for (def file : patchDir.listFiles({ dir, name -> name.endsWith('.patch')  } as FilenameFilter).sort()) {
-                logger.lifecycle 'Applying: {}', file.name
+                for (def file : Patcher.findPatches(patchDir)) {
+                    logger.lifecycle 'Applying: {}', file.name
 
-                def data = new ByteArrayInputStream(file.bytes)
-                def patch = MailPatch.parse(data)
-                data.reset()
+                    def data = new ByteArrayInputStream(file.bytes)
+                    def patch = MailPatch.parseHeader(data)
+                    data.reset()
 
-                apply().setPatch(data).call()
-                commit().setAuthor(patch.author)
-                        .setMessage(patch.message)
-                        .setAll(true)
-                        .call()
-            }
+                    apply().setPatch(data).call()
+                    commit().setAuthor(patch.author)
+                            .setMessage(patch.message)
+                            .setAll(true)
+                            .call()
+                }
 
-            logger.lifecycle 'Successfully applied patches from {} to {}', patchDir, repo
+                logger.lifecycle 'Successfully applied patches from {} to {}', patchDir, repo
+            }
         }
     }
 

src/main/groovy/net/minecrell/gitpatcher/task/patch/MakePatchesTask.groovy

@@ -25,31 +25,85 @@ import static net.minecrell.gitpatcher.git.Patcher.log
 import static net.minecrell.gitpatcher.git.Patcher.openGit
 
 import net.minecrell.gitpatcher.git.MailPatch
-import org.apache.commons.io.FileUtils
+import net.minecrell.gitpatcher.git.Patcher
+import org.eclipse.jgit.diff.DiffFormatter
+import org.eclipse.jgit.patch.Patch
 import org.gradle.api.tasks.TaskAction
 
 class MakePatchesTask extends PatchTask {
 
     @TaskAction
     void makePatches() {
+        File[] patches
         if (patchDir.isDirectory()) {
-            FileUtils.cleanDirectory(patchDir)
+            patches = Patcher.findPatches(patchDir)
         } else {
-            assert patchDir.mkdirs()
+            assert patchDir.mkdirs(), 'Failed to create patch directory'
+            patches = null
         }
 
         openGit(repo) {
-            def counter = 0
+            def i = 0
             for (def commit : log(it, 'origin/upstream')) {
-                counter++
+                def out = new File(patchDir, Patcher.suggestFileName(commit, i+1))
+
+                if (patches != null && i < patches.length) {
+                    def current = patches[i]
+                    if (out == current) {
+                        // The patches are possibly the same - continue checking
+                        def bytes = current.bytes
+                        def header = MailPatch.parseHeader(bytes)
+
+                        if (header.represents(commit)) {
+                            def diff = new ByteArrayOutputStream(current.bytes.length)
+                            def formatter = new DiffFormatter(diff)
+                            formatter.repository = repository
+
+                            try {
+                                // The commit header is the same, now check the diff
+                                def patch = new Patch()
+                                patch.parse(bytes, 0, bytes.length)
+
+                                formatter.format(patch.files)
+                                def currentDiff = diff.toByteArray()
+
+                                diff.reset()
+                                Patcher.formatPatch(formatter, commit)
+                                def newDiff = diff.toByteArray()
+
+                                if (currentDiff == newDiff) {
+                                    // The patches are identical, we can skip this
+                                    logger.lifecycle 'Skipping patch: {} (up-to-date)', current.name
+                                    i++
+                                    continue
+                                }
+                            } finally {
+                                formatter.release()
+                            }
+
+                        }
+                    } else {
+                        // Delete the old patch
+                        assert current.delete(), 'Failed to delete patch'
+                    }
+                }
+
 
-                def out = new File(patchDir, MailPatch.suggestFileName(commit, counter))
                 logger.lifecycle 'Generating patch: {}', out.name
 
-                assert out.createNewFile()
+                out.createNewFile()
                 out.withOutputStream {
                     MailPatch.writePatch(repository, commit, it)
                 }
+
+                i++
+            }
+
+            // Delete patches that don't exist anymore
+            if (patches != null && i < patches.length) {
+                for (; i < patches.length; i++) {
+                    assert patches[i].delete(), 'Failed to delete patch'
+                }
             }
         }
     }

src/main/groovy/net/minecrell/gitpatcher/task/patch/PatchTask.groovy

@@ -21,15 +21,13 @@
  */
 package net.minecrell.gitpatcher.task.patch
 
-import net.minecrell.gitpatcher.task.GitTask
+import net.minecrell.gitpatcher.task.SubmoduleTask
 import org.gradle.api.tasks.InputDirectory
 
-abstract class PatchTask extends GitTask {
+abstract class PatchTask extends SubmoduleTask {
 
     File root
 
-    String submodule
-
     @InputDirectory
     File patchDir