Modified version of D's patchjar.groovy live plugin that uses Favourites Lists for classes to include in patch jar instead of changelists

patchjar.groovy

import com.intellij.ide.bookmark.Bookmark
import com.intellij.ide.bookmark.FileBookmark
import com.intellij.ide.bookmark.BookmarkGroup
import com.intellij.ide.bookmark.BookmarksManager
import com.intellij.ide.favoritesTreeView.FavoritesManager
import com.intellij.ide.projectView.impl.AbstractUrl
import com.intellij.openapi.module.ModuleManager
import com.intellij.openapi.project.Project
import com.intellij.openapi.roots.CompilerModuleExtension
import com.intellij.openapi.roots.ModuleRootManager
import com.intellij.openapi.roots.ProjectRootManager
import com.intellij.openapi.util.Pair
import com.intellij.openapi.vcs.FilePathImpl
import com.intellij.openapi.vcs.ProjectLevelVcsManager
import com.intellij.openapi.vcs.VcsRoot
import com.intellij.openapi.vcs.versionBrowser.CommittedChangeList
import com.intellij.psi.PsiClass
import com.intellij.psi.PsiElement
import com.intellij.psi.PsiJavaFile
import com.intellij.psi.impl.source.PsiJavaFileImpl
import com.intellij.psi.util.PsiUtilBase
import com.intellij.util.TreeItem
import com.intellij.util.io.ZipUtil

import java.util.zip.ZipOutputStream


import com.intellij.openapi.vfs.VirtualFile

import static liveplugin.PluginUtil.*
import static com.intellij.openapi.util.io.FileUtil.toCanonicalPath as canonicalPathOf

// This is a micro-plugin which creates a .jar "patch file" from a specified favourites list.
// It assumes that project is already compiled.
//
// (Note that it can only be executed within this plugin https://github.com/dkandalov/intellij_eval)

// depends-on-plugin com.intellij.java


if (isIdeStartup) return

static List<VcsRoot> vcsRootsIn(Project project) {
  ProjectRootManager.getInstance(project).contentSourceRoots
          .collect{ ProjectLevelVcsManager.getInstance(project).getVcsRootObjectFor(it) }
          .findAll{ it.path != null }.unique()
}

static List<CommittedChangeList> lastCommitsIn(VcsRoot vcsRoot, int numberOfCommitsToLoad = 1) {
  if (numberOfCommitsToLoad == 0) return []

  def changesProvider = vcsRoot.vcs.committedChangesProvider
  def location = changesProvider.getLocationFor(FilePathImpl.create(vcsRoot.path))
  def settings = changesProvider.createDefaultSettings()

  changesProvider.getCommittedChanges(settings, location, numberOfCommitsToLoad)
}

static Collection<VirtualFile> virtualFilesIn(Collection<CommittedChangeList> commits) {
  commits.collectMany{it.changes.collect{it.virtualFile}}.findAll{ isJavaFile(it) }
}

static boolean isJavaFile(VirtualFile file) {
  file != null && file.extension == "java"
}

catchingAll {
  /***** CHANGE THESE TWO BOYS BELOW TO SET THE OUTPUT JAR AND THE CHANGESET TO USE FOR THE CONTENTS. */
  final def outputJarPath = "c:/temp/patch-temp.jar"
//  final def favouritesListName = "cptool"
//  final def favouritesListName = "pnlsummary-2016WK31"
//  final def favouritesListName = "aggregator"
//  final def favouritesListName = "mdxbridge-repo-rates"
//  final def favouritesListName = "mcrp"
//  final def favouritesListName = "EmailTest"
//  final def favouritesListName = "pnlsummary"
//  final def favouritesListName = "usswap"
//  final def favouritesListName = "adhoc"
//  final def favouritesListName = "mdxbridge"
//  final def favouritesListName = "expriscepub"
//  final def favouritesListName = "mark"
//  final def favouritesListName = "bookmanager"
//  final def favouritesListName = "ust"
//  final def favouritesListName = "etd"
//  final def favouritesListName = "limitmonitor"
//  final def favouritesListName = "ignite"
//  final def favouritesListName = "router"
//  final def favouritesListName = "pnlcalc"
//  final def favouritesListName = "cds-calc"
//  final def favouritesListName = "marple"
  final def favouritesListName = "marple2"
//  final def favouritesListName = "pnlcalc"
//  final def favouritesListName = "marple-sql-hack"
//  final def favouritesListName = "fire-cds-calc"
//  final def favouritesListName = "ignite"
//  final def favouritesListName = "flowmonitor"
//  final def favouritesListName = "journal"
//  final def favouritesListName = "mdx-subscriber-connect-mdxprl"
//  final def favouritesListName = "strips"
//  final def favouritesListName = "pnlcalc-2016WK45"
//  final def favouritesListName = "ccts-expricepub"
//  final def favouritesListName = "delta-unity-inflation"
//  final def favouritesListName = "foundrypublisher"

  def modules = ModuleManager.getInstance(project).modules
  def sourceRootPaths = modules.collectMany { module ->
    ModuleRootManager.getInstance(module).sourceRoots.collect { canonicalPathOf(it.path) }
  }
  def compilerOutputPaths = modules.collect { module ->
    def extension = ModuleRootManager.getInstance(module).getModuleExtension(CompilerModuleExtension.class)
    if (extension?.compilerOutputPath?.path == null) null
    else canonicalPathOf(extension.compilerOutputPath.path)
  }.findAll{ it != null }
  def relativePathOf = { path ->
    (sourceRootPaths + compilerOutputPaths).inject(path) { result, pathToExclude -> result.replace(pathToExclude, "") }
  }

//compilerOutputPaths.each {show("compilerOutputPath=" + it)}


  def srcFiles = []
  BookmarkGroup group = BookmarksManager.getInstance(project).getGroup(favouritesListName)
  if (group!=null) {
    if (group.bookmarks != null) {
//      show("group " + group.getName() + " has group.bookmarks.size() " + group.bookmarks.size)
      for (Bookmark b : group.bookmarks) {
        if(b instanceof FileBookmark) {
          FileBookmark fb = (FileBookmark)b
          srcFiles << fb.file.path
          def srcFile = fb.file.path
//          show(relativePathOf(canonicalPathOf(srcFile.substring(0,srcFile.lastIndexOf('/')))))
        }
      }
    }
  }

  srcFiles.each {show("Bookmarked file=" + it)}

  def classFiles = srcFiles.collectMany { srcFile ->
    def relativePathToFileParent = relativePathOf(canonicalPathOf(srcFile.substring(0,srcFile.lastIndexOf('/'))))
    show("srcFile=" + srcFile + ", relativePath=" + relativePathToFileParent)
    compilerOutputPaths
            .collectMany {
              def files = new File(it + relativePathToFileParent).listFiles()
              files != null ? files.toList() : []
            }
            .findAll { outputFile ->
              def fileName = srcFile.substring(srcFile.lastIndexOf('/')+1)
              def outputFilePattern = '^' + fileName + '$'

              // find classes and inner classes
              if(fileName.endsWith(".java")) {
                outputFilePattern = '^' + fileName.replace(".java", "") + '(\\$\\w+)*\\.class$'
              }
//              show("outputFilePattern=" +outputFilePattern)
              outputFile.name.matches(outputFilePattern)
            }
            .collect { [it, relativePathOf(canonicalPathOf(it.absolutePath))] }
  }.unique()



  def patchFile = new File(outputJarPath)
  if (patchFile.exists()) patchFile.delete()

  ZipOutputStream outputStream = new ZipOutputStream(new FileOutputStream(patchFile))
  classFiles.each { entry ->
    show(entry)
    def (file, classFileRelativePath) = entry
    ZipUtil.addFileToZip(outputStream, file, classFileRelativePath, null, null)
  }
  outputStream.close()

  show("Created $patchFile")

}

updated to use intellij bookmarks instead of favourites

updated to allow any bookmarked file that is in the compiler output path to be included in jar, e.g. xml, json, yaml, etc