Repository: groovy
Updated Branches:
  refs/heads/master 25a414f82 -> ff8d74741


GROOVY-8577 Migrate org.codehaus.groovy.tools.GrapeMain.groovy to picocli


Project: http://git-wip-us.apache.org/repos/asf/groovy/repo
Commit: http://git-wip-us.apache.org/repos/asf/groovy/commit/ff8d7474
Tree: http://git-wip-us.apache.org/repos/asf/groovy/tree/ff8d7474
Diff: http://git-wip-us.apache.org/repos/asf/groovy/diff/ff8d7474

Branch: refs/heads/master
Commit: ff8d74741d87133be0a49710470d4b6e23ab1f7e
Parents: 25a414f
Author: Remko Popma <rem...@yahoo.com>
Authored: Fri May 11 01:27:36 2018 +0900
Committer: Paul King <pa...@asert.com.au>
Committed: Fri May 18 09:46:15 2018 +1000

----------------------------------------------------------------------
 .../org/codehaus/groovy/tools/GrapeMain.groovy  | 533 ++++++++++---------
 1 file changed, 283 insertions(+), 250 deletions(-)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/groovy/blob/ff8d7474/src/main/groovy/org/codehaus/groovy/tools/GrapeMain.groovy
----------------------------------------------------------------------
diff --git a/src/main/groovy/org/codehaus/groovy/tools/GrapeMain.groovy 
b/src/main/groovy/org/codehaus/groovy/tools/GrapeMain.groovy
index dd330c3..705cd26 100644
--- a/src/main/groovy/org/codehaus/groovy/tools/GrapeMain.groovy
+++ b/src/main/groovy/org/codehaus/groovy/tools/GrapeMain.groovy
@@ -19,290 +19,323 @@
 package org.codehaus.groovy.tools
 
 import groovy.grape.Grape
-import groovy.transform.Field
-import org.apache.commons.cli.CommandLine
-import org.apache.commons.cli.DefaultParser
-import org.apache.commons.cli.HelpFormatter
-import org.apache.commons.cli.Option
-import org.apache.commons.cli.OptionGroup
-import org.apache.commons.cli.Options
 import org.apache.ivy.util.DefaultMessageLogger
 import org.apache.ivy.util.Message
-
-//commands
-
-@Field install = {arg, cmd ->
-    if (arg.size() > 5 || arg.size() < 3) {
-        println 'install requires two to four arguments: <group> <module> 
[<version> [<classifier>]]'
-        return
-    }
-    def ver = '*'
-    if (arg.size() >= 4) {
-        ver = arg[3]
-    }
-    def classifier = null
-    if (arg.size() >= 5) {
-        classifier = arg[4]
+import picocli.CommandLine
+import picocli.CommandLine.Command
+import picocli.CommandLine.Option
+import picocli.CommandLine.Parameters
+import picocli.CommandLine.ParentCommand
+import picocli.CommandLine.RunLast
+import picocli.CommandLine.Unmatched
+
+@Command(name = "grape", description = "Allows for the inspection and 
management of the local grape cache.",
+        subcommands = [
+                Install.class,
+                Uninstall.class,
+                ListCommand.class,
+                Resolve.class,
+                picocli.CommandLine.HelpCommand.class])
+class GrapeMain implements Runnable {
+    @Option(names = ["-D", "--define"], description = "define a system 
property", paramLabel = "<name=value>")
+    private Map<String, String> properties = new LinkedHashMap<String, 
String>()
+
+    @Option(names = ["-r", "--resolver"], description = "define a grab 
resolver (for install)", paramLabel = "<url>")
+    private List<String> resolvers = new ArrayList<String>()
+
+    @Option(names = ["-q", "--quiet"], description = "Log level 0 - only 
errors")
+    private boolean quiet
+
+    @Option(names = ["-w", "--warn"], description = "Log level 1 - errors and 
warnings")
+    private boolean warn
+
+    @Option(names = ["-i", "--info"], description = "Log level 2 - info")
+    private boolean info
+
+    @Option(names = ["-V", "--verbose"], description = "Log level 3 - verbose")
+    private boolean verbose
+
+    @Option(names = ["-d", "--debug"], description = "Log level 4 - debug")
+    private boolean debug
+
+    @Unmatched List<String> unmatched = new ArrayList<String>()
+
+    private CommandLine parser
+
+    public static void main(String[] args) {
+        GrapeMain grape = new GrapeMain()
+        def parser = new CommandLine(grape)
+        parser.addMixin("helpOptions", new HelpOptionsMixin())
+        parser.subcommands.findAll { k, v -> k != 'help' }.each { k, v -> 
v.addMixin("helpOptions", new HelpOptionsMixin()) }
+
+        grape.parser = parser
+        parser.parseWithHandler(new RunLast(), args)
     }
 
-    // set the instance so we can re-set the logger
-    Grape.getInstance()
-    setupLogging()
+    void run() {
+        if (unmatched) {
+            System.err.println "grape: '${unmatched[0]}' is not a grape 
command. See 'grape --help'"
+        } else {
+            parser.usage(System.out) // if no subcommand was specified
+        }
+    }
 
-    cmd.getOptionValues('r')?.each { String url ->
-        Grape.addResolver(name:url, root:url)
+    private void init() {
+        properties.each { k, v ->
+            System.setProperty(k, v)
+        }
     }
 
-    try {
-        Grape.grab(autoDownload: true, group: arg[1], module: arg[2], version: 
ver, classifier: classifier, noExceptions: true)
-    } catch (Exception e) {
-        println "An error occured : $ex"
+    private void setupLogging(int defaultLevel = 2) { // = Message.MSG_INFO -> 
some parsing error :(
+        if (quiet) {
+            Message.setDefaultLogger(new DefaultMessageLogger(Message.MSG_ERR))
+        } else if (warn) {
+            Message.setDefaultLogger(new 
DefaultMessageLogger(Message.MSG_WARN))
+        } else if (info) {
+            Message.setDefaultLogger(new 
DefaultMessageLogger(Message.MSG_INFO))
+        } else if (verbose) {
+            Message.setDefaultLogger(new 
DefaultMessageLogger(Message.MSG_VERBOSE))
+        } else if (debug) {
+            Message.setDefaultLogger(new 
DefaultMessageLogger(Message.MSG_DEBUG))
+        } else {
+            Message.setDefaultLogger(new DefaultMessageLogger(defaultLevel))
+        }
     }
-}
 
-@Field uninstall = {arg, cmd ->
-    if (arg.size() != 4) {
-        println 'uninstall requires three arguments: <group> <module> 
<version>'
-        // TODO make version optional? support classifier?
-//        println 'uninstall requires two to four arguments, <group> <module> 
[<version>] [<classifier>]'
-        return
+    /**
+     * Defines help options (--help and --version) and a version provider used 
by the top-level command and all subcommands.
+     * Intended to be installed as a picocli mixin.
+     */
+    // IMPLEMENTATION NOTE:
+    // The @Command(mixinStandardHelpOptions = true) attribute cannot be used 
because
+    // the unix standard short option for version help is uppercase -V, while 
previous versions
+    // of this class use lowercase -v. This custom mixin preserves option 
compatibility.
+    @Command(versionProvider = VersionProvider.class, sortOptions = false,
+            parameterListHeading = "%nParameters:%n",
+            optionListHeading = "%nOptions:%n",
+            descriptionHeading = "%n")
+    private static class HelpOptionsMixin {
+        @Option(names = ["-h", "--help"], description = "usage information") 
boolean isHelpRequested
+        @Option(names = ["-v", "--version"], description = "display the Groovy 
and JVM versions") boolean isVersionRequested
     }
-    String group = arg[1]
-    String module = arg[2]
-    String ver = arg[3]
-//    def classifier = null
-
-    // set the instance so we can re-set the logger
-    Grape.getInstance()
-    setupLogging()
-
-    if (!Grape.enumerateGrapes().find {String groupName, Map g ->
-        g.any {String moduleName, List<String> versions ->
-            group == groupName && module == moduleName && ver in versions
-        }
-    }) {
-        println "uninstall did not find grape matching: $group $module $ver"
-        def fuzzyMatches = Grape.enumerateGrapes().findAll { String groupName, 
Map g ->
-            g.any {String moduleName, List<String> versions ->
-                groupName.contains(group) || moduleName.contains(module) ||
-                group.contains(groupName) || module.contains(moduleName)
-            }
-        }
-        if (fuzzyMatches) {
-            println 'possible matches:'
-            fuzzyMatches.each { String groupName, Map g -> println "    
$groupName: $g" }
+
+    private static class VersionProvider implements 
CommandLine.IVersionProvider {
+        String[] getVersion() {
+            String version = GroovySystem.getVersion()
+            return "Groovy Version: $version JVM: 
${System.getProperty('java.version')}"
         }
-        return
     }
-    Grape.instance.uninstallArtifact(group, module, ver)
-}
 
-@Field list = {arg, cmd ->
-    println ""
+    @Command(name = 'install', header = 'Installs a particular grape',
+            synopsisHeading = 'Usage: grape ',
+            description = 'Installs the specified groovy module or maven 
artifact. If a version is specified that specific version will be installed, 
otherwise the most recent version will be used (as if `*` was passed in).')
+    private static class Install implements Runnable {
+        @Parameters(index = '0', arity = '1', description = 'Which module 
group the module comes from. Translates directly to a Maven groupId or an Ivy 
Organization. Any group matching /groovy[x][\\..*]^/ is reserved and may have 
special meaning to the groovy endorsed modules.')
+        String group
 
-    int moduleCount = 0
-    int versionCount = 0
+        @Parameters(index = '1', arity = '1', description = 'The name of the 
module to load. Translated directly to a Maven artifactId or an Ivy artifact.')
+        String module
 
-    // set the instance so we can re-set the logger
-    Grape.getInstance()
-    setupLogging()
+        @Parameters(index = '2', arity = '0..1', description = 'The version of 
the module to use. Either a literal version `1.1-RC3` or an Ivy Range 
`[2.2.1,)` meaning 2.2.1 or any greater version).')
+        String version = '*'
 
-    Grape.enumerateGrapes().each {String groupName, Map group ->
-        group.each {String moduleName, List<String> versions ->
-            println "$groupName $moduleName  $versions"
-            moduleCount++
-            versionCount += versions.size()
-        }
-    }
-    println ""
-    println "$moduleCount Grape modules cached"
-    println "$versionCount Grape module versions cached"
-}
+        @Parameters(index = '3', arity = '0..1', description = 'The optional 
classifier to use (for example, jdk15).')
+        String classifier
 
-@Field resolve = {arg, cmd ->
-    Options options = new Options();
-    
options.addOption(Option.builder("a").hasArg(false).longOpt("ant").build());
-    
options.addOption(Option.builder("d").hasArg(false).longOpt("dos").build());
-    
options.addOption(Option.builder("s").hasArg(false).longOpt("shell").build());
-    
options.addOption(Option.builder("i").hasArg(false).longOpt("ivy").build());
-    CommandLine cmd2 = new DefaultParser().parse(options, arg[1..-1] as 
String[], true);
-    arg = cmd2.args
-
-    // set the instance so we can re-set the logger
-    Grape.getInstance()
-    setupLogging(Message.MSG_ERR)
-
-    if ((arg.size() % 3) != 0) {
-        println 'There needs to be a multiple of three arguments: (group 
module version)+'
-        return
-    }
-    if (args.size() < 3) {
-        println 'At least one Grape reference is required'
-        return
-    }
-    def before, between, after
-    def ivyFormatRequested = false
-
-    if (cmd2.hasOption('a')) {
-        before = '<pathelement location="'
-        between = '">\n<pathelement location="'
-        after = '">'
-    } else if (cmd2.hasOption('d')) {
-        before = 'set CLASSPATH='
-        between = ';'
-        after = ''
-    } else if (cmd2.hasOption('s')) {
-        before = 'export CLASSPATH='
-        between = ':'
-        after = ''
-    } else if (cmd2.hasOption('i')) {
-        ivyFormatRequested = true
-        before = '<dependency '
-        between = '">\n<dependency '
-        after = '">'
-    } else {
-        before = ''
-        between = '\n'
-        after = '\n'
-    }
+        @ParentCommand GrapeMain parentCommand
 
-    iter = arg.iterator()
-    def params = [[:]]
-    def depsInfo = [] // this list will contain the module/group/version info 
of all resolved dependencies
-    if(ivyFormatRequested) {
-        params << depsInfo
-    }
-    while (iter.hasNext()) {
-        params.add([group: iter.next(), module: iter.next(), version: 
iter.next()])
-    }
-    try {
-        def results = []
-        def uris = Grape.resolve(* params)
-        if(!ivyFormatRequested) {
-            for (URI uri: uris) {
-                if (uri.scheme == 'file') {
-                    results += new File(uri).path
-                } else {
-                    results += uri.toASCIIString()
-                }
+        void run() {
+            parentCommand.init()
+
+            // set the instance so we can re-set the logger
+            Grape.getInstance()
+            parentCommand.setupLogging()
+
+            parentCommand.resolvers.each { String url ->
+                Grape.addResolver(name:url, root:url)
             }
-        } else {
-            depsInfo.each { dep ->
-                results += ('org="' + dep.group + '" name="' + dep.module + '" 
revision="' + dep.revision)
+
+            try {
+                Grape.grab(autoDownload: true, group: group, module: module, 
version: version, classifier: classifier, noExceptions: true)
+            } catch (Exception ex) {
+                println "An error occured : $ex"
             }
         }
+    }
 
-        if (results) {
-            println "${before}${results.join(between)}${after}"
-        } else {
-            println 'Nothing was resolved'
+    @Command(name = 'list', header = 'Lists all installed grapes',
+            synopsisHeading = 'Usage: grape ',
+            description = 'Lists locally installed modules (with their full 
maven name in the case of groovy modules) and versions.')
+    private static class ListCommand implements Runnable {
+
+        @ParentCommand GrapeMain parentCommand
+
+        void run() {
+            parentCommand.init()
+
+            println ""
+
+            int moduleCount = 0
+            int versionCount = 0
+
+            // set the instance so we can re-set the logger
+            Grape.getInstance()
+            parentCommand.setupLogging()
+
+            Grape.enumerateGrapes().each {String groupName, Map group ->
+                group.each {String moduleName, List<String> versions ->
+                    println "$groupName $moduleName  $versions"
+                    moduleCount++
+                    versionCount += versions.size()
+                }
+            }
+            println ""
+            println "$moduleCount Grape modules cached"
+            println "$versionCount Grape module versions cached"
         }
-    } catch (Exception e) {
-        println "Error in resolve:\n\t$e.message"
-        if (e.message =~ /unresolved dependency/) println "Perhaps the grape 
is not installed?"
     }
-}
 
-@Field help = { arg, cmd -> grapeHelp() }
-
-@Field commands = [
-    'install': [closure: install,
-        shortHelp: 'Installs a particular grape'],
-    'uninstall': [closure: uninstall,
-        shortHelp: 'Uninstalls a particular grape (non-transitively removes 
the respective jar file from the grape cache)'],
-    'list': [closure: list,
-        shortHelp: 'Lists all installed grapes'],
-    'resolve': [closure: resolve,
-        shortHelp: 'Enumerates the jars used by a grape'],
-    'help': [closure: help,
-        shortHelp: 'Usage information']
-]
-
-@Field grapeHelp = {
-    int spacesLen = commands.keySet().max {it.length()}.length() + 3
-    String spaces = ' ' * spacesLen
-
-    PrintWriter pw = new PrintWriter(binding.variables.out ?: System.out)
-    new HelpFormatter().printHelp(
-            pw,
-            80,
-            "grape [options] <command> [args]\n",
-            "options:",
-            options,
-            2,
-            4,
-            null, // footer
-            true);
-    pw.flush()
-
-    println ""
-    println "commands:"
-    commands.each {String k, v ->
-        println "  ${(k + spaces).substring(0, spacesLen)} $v.shortHelp"
-    }
-    println ""
-}
+    @Command(name = 'resolve', header = 'Enumerates the jars used by a grape',
+            synopsisHeading = 'Usage: grape ',
+            description = 'Prints the file locations of the jars representing 
the artifcats for the specified module(s) and the respective transitive 
dependencies.')
+    private static class Resolve implements Runnable {
 
-@Field setupLogging = {int defaultLevel = 2 -> // = Message.MSG_INFO -> some 
parsing error :(
-    if (cmd.hasOption('q')) {
-        Message.setDefaultLogger(new DefaultMessageLogger(Message.MSG_ERR))
-    } else if (cmd.hasOption('w')) {
-        Message.setDefaultLogger(new DefaultMessageLogger(Message.MSG_WARN))
-    } else if (cmd.hasOption('i')) {
-        Message.setDefaultLogger(new DefaultMessageLogger(Message.MSG_INFO))
-    } else if (cmd.hasOption('V')) {
-        Message.setDefaultLogger(new DefaultMessageLogger(Message.MSG_VERBOSE))
-    } else if (cmd.hasOption('d')) {
-        Message.setDefaultLogger(new DefaultMessageLogger(Message.MSG_DEBUG))
-    } else {
-        Message.setDefaultLogger(new DefaultMessageLogger(defaultLevel))
-    }
-}
+        @Option(names = ['-a', '--ant'], description = 'Express dependencies 
in a format applicable for an ant script')
+        private boolean ant
 
-// command line parsing
-@Field Options options = new Options();
+        @Option(names = ['-d', '--dos'], description = 'Express dependencies 
in a format applicable for a windows batch file')
+        private boolean dos
 
-options.addOption(Option.builder("D").longOpt("define").desc("define a system 
property").numberOfArgs(2).valueSeparator().argName("name=value").build());
-options.addOption(Option.builder("r").longOpt("resolver").desc("define a grab 
resolver (for install)").hasArg(true).argName("url").build());
-options.addOption(Option.builder("h").hasArg(false).desc("usage 
information").longOpt("help").build());
+        @Option(names = ['-s', '--shell'], description = 'Express dependencies 
in a format applicable for a unix shell script')
+        private boolean shell
 
-// Logging Level Options
-options.addOptionGroup(
-        new OptionGroup()
-                .addOption(Option.builder("q").hasArg(false).desc("Log level 0 
- only errors").longOpt("quiet").build())
-                .addOption(Option.builder("w").hasArg(false).desc("Log level 1 
- errors and warnings").longOpt("warn").build())
-                .addOption(Option.builder("i").hasArg(false).desc("Log level 2 
- info").longOpt("info").build())
-                .addOption(Option.builder("V").hasArg(false).desc("Log level 3 
- verbose").longOpt("verbose").build())
-                .addOption(Option.builder("d").hasArg(false).desc("Log level 4 
- debug").longOpt("debug").build())
-)
-options.addOption(Option.builder("v").hasArg(false).desc("display the Groovy 
and JVM versions").longOpt("version").build());
+        @Option(names = ['-i', '--ivy'], description = 'Express dependencies 
in an ivy-like format')
+        private boolean ivyFormatRequested
 
-@Field CommandLine cmd
+        @ParentCommand GrapeMain parentCommand
 
-cmd = new DefaultParser().parse(options, args, true);
+        void run() {
+            parentCommand.init()
 
-if (cmd.hasOption('h')) {
-    grapeHelp()
-    return
-}
+            // set the instance so we can re-set the logger
+            Grape.getInstance()
+            parentCommand.setupLogging(Message.MSG_ERR)
 
-if (cmd.hasOption('v')) {
-    String version = GroovySystem.getVersion();
-    println "Groovy Version: $version JVM: 
${System.getProperty('java.version')}"
-    return
-}
+            if ((arg.size() % 3) != 0) {
+                println 'There needs to be a multiple of three arguments: 
(group module version)+'
+                return
+            }
+            if (args.size() < 3) {
+                println 'At least one Grape reference is required'
+                return
+            }
+            def before, between, after
+
+            if (ant) {
+                before = '<pathelement location="'
+                between = '">\n<pathelement location="'
+                after = '">'
+            } else if (dos) {
+                before = 'set CLASSPATH='
+                between = ';'
+                after = ''
+            } else if (shell) {
+                before = 'export CLASSPATH='
+                between = ':'
+                after = ''
+            } else if (ivy) {
+                before = '<dependency '
+                between = '">\n<dependency '
+                after = '">'
+            } else {
+                before = ''
+                between = '\n'
+                after = '\n'
+            }
 
-if (options.hasOption('D')) {
-    cmd.getOptionProperties('D')?.each { k, v ->
-        System.setProperty(k, v)
+            iter = arg.iterator()
+            def params = [[:]]
+            def depsInfo = [] // this list will contain the 
module/group/version info of all resolved dependencies
+            if (ivyFormatRequested) {
+                params << depsInfo
+            }
+            while (iter.hasNext()) {
+                params.add([group: iter.next(), module: iter.next(), version: 
iter.next()])
+            }
+            try {
+                def results = []
+                def uris = Grape.resolve(* params)
+                if(!ivyFormatRequested) {
+                    for (URI uri: uris) {
+                        if (uri.scheme == 'file') {
+                            results += new File(uri).path
+                        } else {
+                            results += uri.toASCIIString()
+                        }
+                    }
+                } else {
+                    depsInfo.each { dep ->
+                        results += ('org="' + dep.group + '" name="' + 
dep.module + '" revision="' + dep.revision)
+                    }
+                }
+
+                if (results) {
+                    println "${before}${results.join(between)}${after}"
+                } else {
+                    println 'Nothing was resolved'
+                }
+            } catch (Exception e) {
+                println "Error in resolve:\n\t$e.message"
+                if (e.message =~ /unresolved dependency/) println "Perhaps the 
grape is not installed?"
+            }
+        }
     }
-}
 
-String[] arg = cmd.args
-if (arg?.length == 0) {
-    grapeHelp()
-} else if (commands.containsKey(arg[0])) {
-    commands[arg[0]].closure(arg, cmd)
-} else {
-    println "grape: '${arg[0]}' is not a grape command. See 'grape --help'"
+    @Command(name = 'uninstall',
+            synopsisHeading = 'Usage: grape ',
+            description = 'Uninstalls a particular grape (non-transitively 
removes the respective jar file from the grape cache).')
+    private static class Uninstall implements Runnable {
+        @Parameters(index = '0', arity = '1', description = 'Which module 
group the module comes from. Translates directly to a Maven groupId or an Ivy 
Organization. Any group matching /groovy[x][\\..*]^/ is reserved and may have 
special meaning to the groovy endorsed modules.')
+        String group
+
+        @Parameters(index = '1', arity = '1', description = 'The name of the 
module to load. Translated directly to a Maven artifactId or an Ivy artifact.')
+        String module
+
+        @Parameters(index = '2', arity = '1', description = 'The version of 
the module to use. Either a literal version `1.1-RC3` or an Ivy Range 
`[2.2.1,)` meaning 2.2.1 or any greater version).')
+        String version
+
+        // TODO make version optional? support classifier?
+        //@Parameters(index = '3', arity = '0..1', description = 'The optional 
classifier to use (for example, jdk15).')
+        //String classifier;
+
+        @ParentCommand GrapeMain parentCommand
+
+        void run() {
+            parentCommand.init()
+
+            // set the instance so we can re-set the logger
+            Grape.getInstance()
+            parentCommand.setupLogging()
+
+            if (!Grape.enumerateGrapes().find {String groupName, Map g ->
+                g.any {String moduleName, List<String> versions ->
+                    group == groupName && module == moduleName && version in 
versions
+                }
+            }) {
+                println "uninstall did not find grape matching: $group $module 
$version"
+                def fuzzyMatches = Grape.enumerateGrapes().findAll { String 
groupName, Map g ->
+                    g.any {String moduleName, List<String> versions ->
+                        groupName.contains(group) || 
moduleName.contains(module) ||
+                                group.contains(groupName) || 
module.contains(moduleName)
+                    }
+                }
+                if (fuzzyMatches) {
+                    println 'possible matches:'
+                    fuzzyMatches.each { String groupName, Map g -> println "   
 $groupName: $g" }
+                }
+                return
+            }
+            Grape.instance.uninstallArtifact(group, module, version)
+        }
+    }
 }

Reply via email to