pointcutNames = PointcutFactory.docRegistry
+ pointcutNames.each { pointcutName, pointcutDoc ->
+ method name: pointcutName, type: IPointcut, params: [pointcutArg: Object], doc: pointcutDoc, isDeprecated: PointcutFactory.deprecatedRegistry.contains(pointcutName)
+ }
+
+ method name: 'contribute',
+ type: void,
+ params: [pointcut: IPointcut, contributionBlock: Closure],
+ doc: 'Associates a pointcut expression with a contribution block.'
+
+ method name: 'registerPointcut',
+ type: void,
+ params: [name: String, pointcutBody: Closure],
+ doc: 'Registers a custom pointcut. This pointcut is only available from within the current script. You must specify a name for the pointcut as well as a closure that evaluates whether or not there is a match.'
+
+ method name: 'supportsVersion',
+ type: void,
+ params: [versionConstraints: Map],
+ doc: '''\
+ Specifies that this script is only active when the specified version constraints are met. Currently, the
+ following constraint keys are available: {@code groovy}, {@code groovyEclipse}, and {@code grailsTooling}.
+ For example, to indicate that a script requires both Groovy 1.7.10 or later and Groovy-Eclipse 2.1.3 or later:
+ supportsVersion(groovy: '1.7.10', groovyEclipse: '2.1.3')
+ '''.stripIndent()
+
+ method name: 'log', type: void, params: [message: String], doc: 'Logs a message to the Groovy Event Console.'
+}
+
+// Here, specify everything that can be used inside of an accept block (also called a Contribution Group)
+(dsldFile & insideContribution()).accept {
+ provider = 'the meta-DSLD script'
+
+ property name : 'provider', type: String, doc: 'Specifies a Provider for the current contribution. This provider is displayed during content assist and in other places to give a quick hint as to where this contribution elementcomes from.'
+
+ method name: 'property',
+ namedParams: [
+ name: String,
+ type: Object,
+ isStatic: boolean
+ ],
+ optionalParams: [
+ isDeprecated: Boolean,
+ declaringType: Object,
+ provider: String,
+ doc: String
+ ],
+ doc: 'Specifies a new property contribution. name is mandatory, but all other parameters are optional.'
+
+ method name: 'method',
+ namedParams: [
+ name: String,
+ type: Object,
+ params: Map
+ ],
+ optionalParams: [
+ optionalParams: Map,
+ namedParams: Map,
+ isStatic: Boolean,
+ isDeprecated: Boolean,
+ declaringType: Object,
+ provider: String,
+ doc: String
+ ],
+ doc: '''\
+ Specifies a new property contribution. name is mandatory, but all other parameters are optional.
+ Use {@code namedParams} to specify parameters that should be named, and use {@code optionalParams} to
+ specify parameters that will not appear in content assist.
+ '''.stripIndent()
+
+ method name: 'params',
+ params: [node: MethodNode],
+ type: 'java.util.Map',
+ doc: '''\
+ Returns the parameter names and types of the given method node. Parameter name resolution is performed
+ using the enclosing project's classpath.
+ '''.stripIndent()
+
+ method name: 'delegatesToCategory',
+ params: [type: Object],
+ isDeprecated: true,
+ doc : '''\
+ Specifies that the currentType delegates to the given type. The currentType is the type being analyzed.
+ And the given type is specified as a parameter (either a String, Class, AnnotatedNode). All methods of
+ the given type will be available from the currentType.
+ '''.stripIndent()
+
+ method name: 'delegatesToUseNamedArgs',
+ params: [type: Object],
+ isDeprecated: true,
+ doc: '''\
+ Specifies that the currentType delegates to the given type. The currentType is the type being analyzed.
+ And the given type is specified as a parameter (either a String, Class, or ClassNode). All fields and
+ methods of the given type will be available from the currentType.
+ Named arguments will be used for all methods.
+ '''.stripIndent()
+
+ method name : 'delegatesTo',
+ namedParams: [type: Object],
+ optionalParams: [useNamed: Boolean, except: 'java.util.List', asCategory: Boolean],
+ doc: '''\
+ Specifies that the currentType delegates to the given type. The currentType is the type being analyzed.
+ And the given type is specified as a parameter (either a String, Class, or ClassNode). All fields and
+ methods of the given type will be available from the currentType.
+ This variant allows you to specify options through the optional arguments.
+ @param type (required) type to delegate to
+ @param except (optional) list of method names to exclude from the delegation
+ @param useNamed (optional) boolean and if true named arguments are used
+ @param asCategory (optional) boolean and if true, this delegation is treated as a category and the first
+ parameter of each method is used to see if it is applicable for the current caller
+ '''.stripIndent()
+
+ method name: 'setDelegateType',
+ type: void,
+ params: [newDelegateType: String],
+ doc: '''\
+ Sets the delegate type inside a closure. This is different from {@code delegatesTo} in that the receiving
+ type is changed in the current scope. In {@code delegatesTo}, the scope is not changed -- rather, the
+ methods of the delegate are added to the target type's list of recognized methods.
+ '''.stripIndent()
+
+ method name: 'log', type: void, params: [message: String], doc: 'Logs a message to the Groovy Event Console.'
+
+ property name: 'currentType', type: ClassNode, doc: 'This is the declaring type of the current expression being evaluated.'
+
+ property name: 'currentNode', type: ASTNode, doc: 'This is the ASTNode being evaluated.'
+
+ property name: 'enclosingNode', type: ASTNode, doc: 'This is the ASTNode enclosing the ASTNode being evaluated.'
+
+ property name: 'wormhole', type: Map, doc: 'Use the wormhole to stuff in values calculated in one contribution group to make it available later in another contribution group.'
+
+ // extract all bindings from the wormhole and add them as contributions
+ for (binding in wormhole.bindings) {
+ property name: binding, type: Collection, doc: 'Binding created from pointcut'
+ }
+}
+
+// Adds the contributions for inside a 'registerPointcut' call. User-registered pointcuts are not fully fleshed out yet, so best not to use them yet.
+(dsldFile & inClosure() & enclosingCallName('registerPointcut')).accept {
+ // a little naughty again...reference an internal Groovy-Eclipse type; this may be removed in future versions
+ property name: 'currentScope', type: org.eclipse.jdt.groovy.search.VariableScope
+ property name: 'currenType', type: ClassNode
+}
diff --git a/base/org.codehaus.groovy26/plugin_dsld_support/dsld/swing_builder.dsld b/base/org.codehaus.groovy26/plugin_dsld_support/dsld/swing_builder.dsld
new file mode 100644
index 0000000000..faf4608aa4
--- /dev/null
+++ b/base/org.codehaus.groovy26/plugin_dsld_support/dsld/swing_builder.dsld
@@ -0,0 +1,150 @@
+/*
+ * Copyright 2009-2018 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package dsld
+
+import java.awt.*
+import javax.swing.*
+
+/**
+ * This is the DSLD for SwingBuilder
+ *
+ * @author Andrew Eisenberg
+ */
+contribute(currentType('groovy.swing.SwingBuilder')) {
+ provider = '{@link groovy.swing.SwingBuilder SwingBuilder} DSL'
+
+ method name: 'action',
+ type: Action,
+ useNamedArgs: true,
+ params: [
+ name: String,
+ shortDescription: String,
+ smallIcon: String,
+ accelerator: String,
+ closure: Closure
+ ],
+ doc: '''\
+ Actions are the lifeblood of a full fledged swing application. Other sources can expound on their usefullness.
+
see http://groovy.codehaus.org/SwingBuilder.action
+ '''.stripIndent()
+
+ method name: 'frame',
+ type: JFrame,
+ useNamedArgs: true,
+ params: [
+ contentPane: Container,
+ defaultCloseOperation: int,
+ title: String,
+ glassPane: Component,
+ layeredPane: JLayeredPane,
+ contentPane: Container
+ ],
+ doc: '''\
+ Generates a JFrame.
+
see http://groovy.codehaus.org/SwingBuilder.frame
+ '''.stripIndent()
+
+ def add = { String name, type ->
+ String doc = "See SwingBuilder.${name}"
+ method name: name, type: type, doc: doc
+ }
+
+ // and so on...
+ add('actions', List)
+ add('bean', Void)
+ add('bind', 'org.codehaus.groovy.binding.FullBinding')
+ add('borderLayout', BorderLayout)
+ add('boundedRangeModel', DefaultBoundedRangeModel)
+ add('box', Box)
+ add('boxLayout', BoxLayout)
+ add('button', JButton)
+ add('buttonGroup', ButtonGroup)
+ add('cardLayout', CardLayout)
+ add('checkBox', JCheckBox)
+ add('checkBoxMenuItem', JCheckBoxMenuItem)
+ add('closureColumn', 'groovy.model.DefaultTableColumn')
+ add('compoundBorder', border.CompoundBorder)
+ add('colorChooser', JColorChooser)
+ add('comboBox', JComboBox)
+ add('container', Container)
+ add('desktopPane', JDesktopPane)
+ add('dialog', JDialog)
+ add('editorPane', JEditorPane)
+ add('emptyBorder', border.EmptyBorder)
+ add('etchedBorder', border.EtchedBorder)
+ add('fileChooser', JFileChooser)
+ add('flowLayout', FlowLayout)
+ add('formattedTextField', JFormattedTextField)
+ add('gbc', GridBagConstraints)
+ add('gridBagConstraints', GridBagConstraints)
+ add('glue', Component)
+ add('gridBagConstraints', GridBagConstraints)
+ add('gridBagLayout', GridBagLayout)
+ add('gridLayout', GridLayout)
+ add('hbox', Box)
+ add('hglue', Component)
+ add('hstrut', Component)
+ add('internalFrame', JInternalFrame)
+ add('label', JLabel)
+ add('layeredPane', JLayeredPane)
+ add('list', JList)
+ add('loweredBevelBorder', border.BevelBorder)
+ add('loweredEtchedBorder', border.EtchedBorder)
+ add('map', Map)
+ add('matteBorder', border.MatteBorder)
+ add('menu', JMenu)
+ add('menuBar', JMenuBar)
+ add('menuItem', JMenuItem)
+ add('optionPane', JOptionPane)
+ add('overlayLayout', OverlayLayout)
+ add('panel', JPanel)
+ add('passwordField', JPasswordField)
+ add('popupMenum', JPopupMenu)
+ add('progressBar', JProgressBar)
+ add('propertyColumn', table.TableColumn)
+ add('radioButton', JRadioButton)
+ add('radioButtonMenuItem', JRadioButtonMenuItem)
+ add('rigidArea', Component)
+ add('scrollBar', JScrollBar)
+ add('scrollPane', JScrollPane)
+ add('separator', JSeparator)
+ add('slider', JSlider)
+ add('spinner', JSpinner)
+ add('spinnerDateModel', SpinnerDateModel)
+ add('spinnerListModel', SpinnerListModel)
+ add('spinnerNumberModel', SpinnerNumberModel)
+ add('splitPane', JSplitPane)
+ add('springLayout', SpringLayout)
+ add('tabbedPane', JTabbedPane)
+ add('table', JTable)
+ add('tableColumn', table.TableColumn)
+ add('tableLayout', 'groovy.swing.impl.TableLayoutRow')
+ add('tableModel', table.TableModel)
+ add('td', 'groovy.swing.impl.TableLayoutCell')
+ add('textArea', JTextArea)
+ add('textField', JTextField)
+ add('textPane', JTextPane)
+ add('toggleButton', JToggleButton)
+ add('toolbar', JToolBar)
+ add('tr', 'groovy.swing.impl.TableLayoutRow')
+ add('tree', JTree)
+ add('vbox', Box)
+ add('vglue', Component)
+ add('viewport', JViewport)
+ add('vstrut', Component)
+ add('widget', Component)
+ add('window', JWindow)
+}
diff --git a/base/org.codehaus.groovy26/plugin_dsld_support/readme.txt b/base/org.codehaus.groovy26/plugin_dsld_support/readme.txt
new file mode 100644
index 0000000000..f044a53aa1
--- /dev/null
+++ b/base/org.codehaus.groovy26/plugin_dsld_support/readme.txt
@@ -0,0 +1,5 @@
+This folder contains some standard DSL descriptor files that are
+specific to this version of Groovy-Eclipse and are applicable to
+all projects in your workspace. In general, you should not edit
+the files here. If you want to add custom DSLDs for your entire
+workspace, then you should add them to ~/.groovy/greclipse/dsld.
diff --git a/base/org.codehaus.groovy26/pom.xml b/base/org.codehaus.groovy26/pom.xml
new file mode 100644
index 0000000000..31525764fa
--- /dev/null
+++ b/base/org.codehaus.groovy26/pom.xml
@@ -0,0 +1,33 @@
+
+ 4.0.0
+
+ ../../pom.xml
+ org.codehaus.groovy.eclipse
+ org.codehaus.groovy.eclipse.parent
+ 3.0.0-SNAPSHOT
+
+ org.codehaus.groovy.eclipse
+ org.codehaus.groovy
+ 2.6.0-SNAPSHOT
+ eclipse-plugin
+
+
+
+
+ maven-clean-plugin
+ 2.5
+
+
+
+ ${basedir}
+
+ eclipse-trace.jar
+ groovy-eclipse.jar
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/base/org.codehaus.groovy26/src-trace/org/codehaus/groovy/eclipse/DefaultGroovyLogger.java b/base/org.codehaus.groovy26/src-trace/org/codehaus/groovy/eclipse/DefaultGroovyLogger.java
new file mode 100644
index 0000000000..beb6fd5aca
--- /dev/null
+++ b/base/org.codehaus.groovy26/src-trace/org/codehaus/groovy/eclipse/DefaultGroovyLogger.java
@@ -0,0 +1,34 @@
+/*
+ * Copyright 2009-2017 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.codehaus.groovy.eclipse;
+
+import java.util.Date;
+
+/**
+ * Default logger logs to sysout and includes a timestamp
+ *
+ * @author Andrew Eisenberg
+ */
+public class DefaultGroovyLogger implements IGroovyLogger {
+
+ public void log(TraceCategory category, String message) {
+ System.out.println(category.label + " : " + new Date() + " : " + message);
+ }
+
+ public boolean isCategoryEnabled(TraceCategory category) {
+ return true;
+ }
+}
diff --git a/base/org.codehaus.groovy26/src-trace/org/codehaus/groovy/eclipse/GroovyLogManager.java b/base/org.codehaus.groovy26/src-trace/org/codehaus/groovy/eclipse/GroovyLogManager.java
new file mode 100644
index 0000000000..724c46b5a4
--- /dev/null
+++ b/base/org.codehaus.groovy26/src-trace/org/codehaus/groovy/eclipse/GroovyLogManager.java
@@ -0,0 +1,171 @@
+/*
+ * Copyright 2009-2017 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.codehaus.groovy.eclipse;
+
+import java.io.PrintWriter;
+import java.io.StringWriter;
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * Manages the current {@link IGroovyLogger} instance.
+ *
+ * NOTE: This class is a singleton.
+ */
+// Some code here borrowed from org.eclipse.ajdt.core.AJLog under EPL license
+// See http://www.eclipse.org/legal/epl-v10.html
+public class GroovyLogManager {
+ public static final GroovyLogManager manager = new GroovyLogManager();
+
+ private GroovyLogManager() {
+ }
+
+ private IGroovyLogger[] loggers;
+
+ // only use default logger if no others are registered
+ private final IGroovyLogger defaultLogger = new DefaultGroovyLogger();
+
+ private final Map timers = new HashMap<>();
+
+ private boolean useDefaultLogger;
+
+ /**
+ * @return true if logger was added; false if not if not added --
+ * then this means the exact logger is already in the list
+ */
+ public boolean addLogger(IGroovyLogger logger) {
+ int newIndex;
+ if (loggers == null) {
+ loggers = new IGroovyLogger[1];
+ newIndex = 0;
+ } else {
+ // check to see if already there
+ for (IGroovyLogger igl : loggers) {
+ if (igl == logger) {
+ return false;
+ }
+ }
+ newIndex = loggers.length;
+ IGroovyLogger[] newLoggers = new IGroovyLogger[newIndex + 1];
+ System.arraycopy(loggers, 0, newLoggers, 0, newIndex);
+ loggers = newLoggers;
+ }
+ loggers[newIndex] = logger;
+ return true;
+ }
+
+ /**
+ * Removes the logger from the logger list.
+ *
+ * @return true iff found and removed; false iff nothing found
+ */
+ public boolean removeLogger(IGroovyLogger logger) {
+ if (logger != null && loggers != null) {
+ int foundIndex = -1;
+ for (int i = 0, n = loggers.length; i < n; i += 1) {
+ if (loggers[i] == logger) {
+ foundIndex = i;
+ }
+ }
+ if (foundIndex >= 0) {
+ if (loggers.length > 1) {
+ IGroovyLogger[] newLoggers = new IGroovyLogger[loggers.length - 1];
+ if (foundIndex > 0) {
+ System.arraycopy(loggers, 0, newLoggers, 0, foundIndex);
+ }
+ System.arraycopy(loggers, foundIndex + 1, newLoggers, foundIndex, loggers.length - foundIndex - 1);
+ loggers = newLoggers;
+ } else {
+ loggers = null;
+ }
+ return true;
+ }
+ }
+ // not found
+ return false;
+ }
+
+ public void logStart(String event) {
+ timers.put(event, System.currentTimeMillis());
+ }
+
+ public void logEnd(String event, TraceCategory category) {
+ logEnd(event, category, null);
+ }
+
+ public void logEnd(String event, TraceCategory category, String message) {
+ Long then = timers.get(event);
+ if (then != null) {
+ if (hasLoggers()) {
+ long now = System.currentTimeMillis();
+ long elapsed = now - then.longValue();
+ if (message != null && !message.isEmpty()) {
+ log(category, "Event complete: " + elapsed + "ms: " + event + " (" + message + ")");
+ } else {
+ log(category, "Event complete: " + elapsed + "ms: " + event);
+ }
+ }
+ timers.remove(event);
+ }
+ }
+
+ public void log(String message) {
+ log(TraceCategory.DEFAULT, message);
+ }
+
+ public void log(TraceCategory category, String message) {
+ if (!hasLoggers()) {
+ return;
+ }
+
+ if (loggers != null) {
+ for (IGroovyLogger logger : loggers) {
+ if (logger.isCategoryEnabled(category)) {
+ logger.log(category, message);
+ }
+ }
+ }
+
+ if (useDefaultLogger) {
+ defaultLogger.log(category, message);
+ }
+ }
+
+ /**
+ * Call this method to check if any loggers are currently
+ * installed. Doing so can help avoid creating costly
+ * logging messages unless required.
+ */
+ public boolean hasLoggers() {
+ return loggers != null || useDefaultLogger;
+ }
+
+ /**
+ * Enables/disables the default logger (printing to sysout).
+ */
+ public void setUseDefaultLogger(boolean useDefaultLogger) {
+ this.useDefaultLogger = useDefaultLogger;
+ }
+
+ public void logException(TraceCategory cat, Throwable t) {
+ if (hasLoggers()) {
+ // only log if logger is available, otherwise, ignore
+ StringWriter writer = new StringWriter();
+ t.printStackTrace(new PrintWriter(writer));
+ log(cat, "Exception caught.\n" + writer.getBuffer());
+ }
+ }
+}
diff --git a/base/org.codehaus.groovy26/src-trace/org/codehaus/groovy/eclipse/IGroovyLogger.java b/base/org.codehaus.groovy26/src-trace/org/codehaus/groovy/eclipse/IGroovyLogger.java
new file mode 100644
index 0000000000..75f56d8e3a
--- /dev/null
+++ b/base/org.codehaus.groovy26/src-trace/org/codehaus/groovy/eclipse/IGroovyLogger.java
@@ -0,0 +1,28 @@
+/*
+ * Copyright 2009-2017 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.codehaus.groovy.eclipse;
+
+/**
+ * A means to send log messages to a logger.
+ *
+ * @author Andrew Eisenberg
+ */
+public interface IGroovyLogger {
+
+ void log(TraceCategory category, String message);
+
+ boolean isCategoryEnabled(TraceCategory category);
+}
diff --git a/base/org.codehaus.groovy26/src-trace/org/codehaus/groovy/eclipse/LoggerTest.java b/base/org.codehaus.groovy26/src-trace/org/codehaus/groovy/eclipse/LoggerTest.java
new file mode 100644
index 0000000000..77d9b495e7
--- /dev/null
+++ b/base/org.codehaus.groovy26/src-trace/org/codehaus/groovy/eclipse/LoggerTest.java
@@ -0,0 +1,102 @@
+/*
+ * Copyright 2009-2017 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.codehaus.groovy.eclipse;
+
+import junit.framework.TestCase;
+
+/**
+ * Simple test to make sure that logs are added and removed properly.
+ *
+ * @author Andrew Eisenberg
+ */
+public class LoggerTest extends TestCase {
+
+ public void testLoggers() throws Exception {
+ DefaultGroovyLogger l1 = new DefaultGroovyLogger();
+ DefaultGroovyLogger l2 = new DefaultGroovyLogger();
+ DefaultGroovyLogger l3 = new DefaultGroovyLogger();
+ DefaultGroovyLogger l4 = new DefaultGroovyLogger();
+ DefaultGroovyLogger l5 = new DefaultGroovyLogger();
+
+ assertTrue(GroovyLogManager.manager.addLogger(l1));
+ assertFalse(GroovyLogManager.manager.addLogger(l1));
+ assertTrue(GroovyLogManager.manager.addLogger(l2));
+ assertFalse(GroovyLogManager.manager.addLogger(l2));
+ assertTrue(GroovyLogManager.manager.addLogger(l3));
+ assertFalse(GroovyLogManager.manager.addLogger(l3));
+ assertTrue(GroovyLogManager.manager.addLogger(l4));
+ assertFalse(GroovyLogManager.manager.addLogger(l4));
+ assertTrue(GroovyLogManager.manager.addLogger(l5));
+ assertFalse(GroovyLogManager.manager.addLogger(l5));
+
+ assertTrue(GroovyLogManager.manager.removeLogger(l1));
+ assertFalse(GroovyLogManager.manager.removeLogger(l1));
+ assertTrue(GroovyLogManager.manager.removeLogger(l2));
+ assertFalse(GroovyLogManager.manager.removeLogger(l2));
+ assertTrue(GroovyLogManager.manager.removeLogger(l3));
+ assertFalse(GroovyLogManager.manager.removeLogger(l3));
+ assertTrue(GroovyLogManager.manager.removeLogger(l4));
+ assertFalse(GroovyLogManager.manager.removeLogger(l4));
+ assertTrue(GroovyLogManager.manager.removeLogger(l5));
+ assertFalse(GroovyLogManager.manager.removeLogger(l5));
+
+ // now reverse order of removal
+ assertTrue(GroovyLogManager.manager.addLogger(l1));
+ assertFalse(GroovyLogManager.manager.addLogger(l1));
+ assertTrue(GroovyLogManager.manager.addLogger(l2));
+ assertFalse(GroovyLogManager.manager.addLogger(l2));
+ assertTrue(GroovyLogManager.manager.addLogger(l3));
+ assertFalse(GroovyLogManager.manager.addLogger(l3));
+ assertTrue(GroovyLogManager.manager.addLogger(l4));
+ assertFalse(GroovyLogManager.manager.addLogger(l4));
+ assertTrue(GroovyLogManager.manager.addLogger(l5));
+ assertFalse(GroovyLogManager.manager.addLogger(l5));
+
+ assertTrue(GroovyLogManager.manager.removeLogger(l5));
+ assertFalse(GroovyLogManager.manager.removeLogger(l5));
+ assertTrue(GroovyLogManager.manager.removeLogger(l4));
+ assertFalse(GroovyLogManager.manager.removeLogger(l4));
+ assertTrue(GroovyLogManager.manager.removeLogger(l3));
+ assertFalse(GroovyLogManager.manager.removeLogger(l3));
+ assertTrue(GroovyLogManager.manager.removeLogger(l2));
+ assertFalse(GroovyLogManager.manager.removeLogger(l2));
+ assertTrue(GroovyLogManager.manager.removeLogger(l1));
+ assertFalse(GroovyLogManager.manager.removeLogger(l1));
+
+ // now removal from middle
+ assertTrue(GroovyLogManager.manager.addLogger(l1));
+ assertFalse(GroovyLogManager.manager.addLogger(l1));
+ assertTrue(GroovyLogManager.manager.addLogger(l2));
+ assertFalse(GroovyLogManager.manager.addLogger(l2));
+ assertTrue(GroovyLogManager.manager.addLogger(l3));
+ assertFalse(GroovyLogManager.manager.addLogger(l3));
+ assertTrue(GroovyLogManager.manager.addLogger(l4));
+ assertFalse(GroovyLogManager.manager.addLogger(l4));
+ assertTrue(GroovyLogManager.manager.addLogger(l5));
+ assertFalse(GroovyLogManager.manager.addLogger(l5));
+
+ assertTrue(GroovyLogManager.manager.removeLogger(l3));
+ assertFalse(GroovyLogManager.manager.removeLogger(l3));
+ assertTrue(GroovyLogManager.manager.removeLogger(l2));
+ assertFalse(GroovyLogManager.manager.removeLogger(l2));
+ assertTrue(GroovyLogManager.manager.removeLogger(l4));
+ assertFalse(GroovyLogManager.manager.removeLogger(l4));
+ assertTrue(GroovyLogManager.manager.removeLogger(l5));
+ assertFalse(GroovyLogManager.manager.removeLogger(l5));
+ assertTrue(GroovyLogManager.manager.removeLogger(l1));
+ assertFalse(GroovyLogManager.manager.removeLogger(l1));
+ }
+}
diff --git a/base/org.codehaus.groovy26/src-trace/org/codehaus/groovy/eclipse/TraceCategory.java b/base/org.codehaus.groovy26/src-trace/org/codehaus/groovy/eclipse/TraceCategory.java
new file mode 100644
index 0000000000..61307ac2bb
--- /dev/null
+++ b/base/org.codehaus.groovy26/src-trace/org/codehaus/groovy/eclipse/TraceCategory.java
@@ -0,0 +1,84 @@
+/*
+ * Copyright 2009-2017 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.codehaus.groovy.eclipse;
+
+import java.util.Arrays;
+
+/**
+ * @author Andrew Eisenberg
+ */
+public enum TraceCategory {
+
+ DEFAULT("_"),
+ COMPILER("Compiler"),
+ CLASSPATH("Classpath"),
+
+ DSL("DSL"),
+ CODE_SELECT("Code select"),
+ REFACTORING("Refactoring"),
+ AST_TRANSFORM("AST Transforms"),
+ CONTENT_ASSIST("Content assist"),
+ ORGANIZE_IMPORTS("Clean imports");
+
+ TraceCategory(String label) {
+ this.label = label;
+ }
+
+ public final String label;
+
+ private String paddedLabel;
+
+ public String getPaddedLabel() {
+ if (paddedLabel == null) {
+ synchronized (TraceCategory.class) {
+ if (longestLabel == -1) {
+ calculateLongest();
+ }
+ }
+ int extraSpace = longestLabel - label.length();
+ paddedLabel = spaces(extraSpace) + label;
+ }
+ return paddedLabel;
+ }
+
+ private String spaces(int extraSpace) {
+ char[] a = new char[extraSpace];
+ Arrays.fill(a, ' ');
+ return new String(a);
+ }
+
+ private static void calculateLongest() {
+ int maybeLongest = longestLabel;
+ for (TraceCategory category : values()) {
+ maybeLongest = Math.max(category.label.length(), maybeLongest);
+ }
+ longestLabel = maybeLongest;
+ }
+
+ public static String[] stringValues() {
+ if (stringValues == null) {
+ TraceCategory[] values = values();
+ stringValues = new String[values.length];
+ for (int i = 0, n = values.length; i < n; i += 1) {
+ stringValues[i] = values[i].label;
+ }
+ }
+ return stringValues;
+ }
+
+ private static String[] stringValues;
+ private static int longestLabel = -1;
+}
diff --git a/base/org.codehaus.groovy26/src/groovy/grape/GrabAnnotationTransformation.java b/base/org.codehaus.groovy26/src/groovy/grape/GrabAnnotationTransformation.java
new file mode 100644
index 0000000000..05585dfec9
--- /dev/null
+++ b/base/org.codehaus.groovy26/src/groovy/grape/GrabAnnotationTransformation.java
@@ -0,0 +1,665 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package groovy.grape;
+
+import groovy.lang.Grab;
+import groovy.lang.GrabConfig;
+import groovy.lang.GrabExclude;
+import groovy.lang.GrabResolver;
+import groovy.lang.Grapes;
+import groovy.transform.CompilationUnitAware;
+import org.codehaus.groovy.ast.ASTNode;
+import org.codehaus.groovy.ast.AnnotatedNode;
+import org.codehaus.groovy.ast.AnnotationNode;
+import org.codehaus.groovy.ast.ClassCodeVisitorSupport;
+import org.codehaus.groovy.ast.ClassHelper;
+import org.codehaus.groovy.ast.ClassNode;
+import org.codehaus.groovy.ast.ImportNode;
+import org.codehaus.groovy.ast.ModuleNode;
+import org.codehaus.groovy.ast.expr.ConstantExpression;
+import org.codehaus.groovy.ast.expr.Expression;
+import org.codehaus.groovy.ast.expr.ListExpression;
+import org.codehaus.groovy.ast.expr.MapExpression;
+import org.codehaus.groovy.ast.expr.StaticMethodCallExpression;
+import org.codehaus.groovy.ast.stmt.BlockStatement;
+import org.codehaus.groovy.ast.stmt.Statement;
+import org.codehaus.groovy.control.CompilationUnit;
+import org.codehaus.groovy.control.CompilePhase;
+import org.codehaus.groovy.control.SourceUnit;
+import org.codehaus.groovy.control.io.StringReaderSource;
+import org.codehaus.groovy.runtime.DefaultGroovyMethods;
+import org.codehaus.groovy.tools.GrapeUtil;
+import org.codehaus.groovy.transform.ASTTransformation;
+import org.codehaus.groovy.transform.ASTTransformationVisitor;
+import org.codehaus.groovy.transform.AbstractASTTransformation;
+import org.codehaus.groovy.transform.GroovyASTTransformation;
+
+import java.io.File;
+import java.net.URI;
+import java.net.URISyntaxException;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+import static org.codehaus.groovy.ast.tools.GeneralUtils.args;
+import static org.codehaus.groovy.ast.tools.GeneralUtils.callThisX;
+import static org.codehaus.groovy.ast.tools.GeneralUtils.callX;
+import static org.codehaus.groovy.ast.tools.GeneralUtils.constX;
+import static org.codehaus.groovy.ast.tools.GeneralUtils.eqX;
+import static org.codehaus.groovy.ast.tools.GeneralUtils.ifS;
+import static org.codehaus.groovy.ast.tools.GeneralUtils.stmt;
+import static org.codehaus.groovy.transform.AbstractASTTransformation.getMemberStringValue;
+
+/**
+ * Transformation for declarative dependency management.
+ */
+@GroovyASTTransformation(phase=CompilePhase.CONVERSION)
+public class GrabAnnotationTransformation extends ClassCodeVisitorSupport implements ASTTransformation, CompilationUnitAware {
+ private static final String GRAB_CLASS_NAME = Grab.class.getName();
+ private static final String GRAB_DOT_NAME = GRAB_CLASS_NAME.substring(GRAB_CLASS_NAME.lastIndexOf("."));
+ private static final String GRAB_SHORT_NAME = GRAB_DOT_NAME.substring(1);
+
+ private static final String GRABEXCLUDE_CLASS_NAME = GrabExclude.class.getName();
+ private static final String GRABEXCLUDE_DOT_NAME = dotName(GRABEXCLUDE_CLASS_NAME);
+ private static final String GRABEXCLUDE_SHORT_NAME = shortName(GRABEXCLUDE_DOT_NAME);
+
+ private static final String GRABCONFIG_CLASS_NAME = GrabConfig.class.getName();
+ private static final String GRABCONFIG_DOT_NAME = dotName(GRABCONFIG_CLASS_NAME);
+ private static final String GRABCONFIG_SHORT_NAME = shortName(GRABCONFIG_DOT_NAME);
+
+ private static final String GRAPES_CLASS_NAME = Grapes.class.getName();
+ private static final String GRAPES_DOT_NAME = dotName(GRAPES_CLASS_NAME);
+ private static final String GRAPES_SHORT_NAME = shortName(GRAPES_DOT_NAME);
+
+ private static final String GRABRESOLVER_CLASS_NAME = GrabResolver.class.getName();
+ private static final String GRABRESOLVER_DOT_NAME = dotName(GRABRESOLVER_CLASS_NAME);
+ private static final String GRABRESOLVER_SHORT_NAME = shortName(GRABRESOLVER_DOT_NAME);
+
+ private static final ClassNode THREAD_CLASSNODE = ClassHelper.make(Thread.class);
+ private static final ClassNode SYSTEM_CLASSNODE = ClassHelper.make(System.class);
+
+ private static final List GRABEXCLUDE_REQUIRED = Arrays.asList("group", "module");
+ private static final List GRABRESOLVER_REQUIRED = Arrays.asList("name", "root");
+ private static final List GRAB_REQUIRED = Arrays.asList("group", "module", "version");
+ private static final List GRAB_OPTIONAL = Arrays.asList("classifier", "transitive", "conf", "ext", "type", "changing", "force", "initClass");
+ private static final List GRAB_BOOLEAN = Arrays.asList("transitive", "changing", "force", "initClass");
+ private static final Collection GRAB_ALL = DefaultGroovyMethods.plus(GRAB_REQUIRED, GRAB_OPTIONAL);
+ private static final Pattern IVY_PATTERN = Pattern.compile("([a-zA-Z0-9-/._+=]+)#([a-zA-Z0-9-/._+=]+)(;([a-zA-Z0-9-/.\\(\\)\\[\\]\\{\\}_+=,:@][a-zA-Z0-9-/.\\(\\)\\]\\{\\}_+=,:@]*))?(\\[([a-zA-Z0-9-/._+=,]*)\\])?");
+ private static final Pattern ATTRIBUTES_PATTERN = Pattern.compile("(.*;|^)([a-zA-Z0-9]+)=([a-zA-Z0-9.*\\[\\]\\-\\(\\),]*)$");
+
+ private static final String AUTO_DOWNLOAD_SETTING = Grape.AUTO_DOWNLOAD_SETTING;
+ private static final String DISABLE_CHECKSUMS_SETTING = Grape.DISABLE_CHECKSUMS_SETTING;
+ private static final String SYSTEM_PROPERTIES_SETTING = Grape.SYSTEM_PROPERTIES_SETTING;
+
+ private static String dotName(String className) {
+ return className.substring(className.lastIndexOf("."));
+ }
+
+ private static String shortName(String className) {
+ return className.substring(1);
+ }
+
+ boolean allowShortGrab;
+ Set grabAliases;
+ List grabAnnotations;
+
+ boolean allowShortGrabExcludes;
+ Set grabExcludeAliases;
+ List grabExcludeAnnotations;
+
+ boolean allowShortGrabConfig;
+ Set grabConfigAliases;
+ List grabConfigAnnotations;
+
+ boolean allowShortGrapes;
+ Set grapesAliases;
+ List grapesAnnotations;
+
+ boolean allowShortGrabResolver;
+ Set grabResolverAliases;
+ List grabResolverAnnotations;
+
+ CompilationUnit compilationUnit;
+ SourceUnit sourceUnit;
+ ClassLoader loader;
+ boolean initContextClassLoader;
+ Boolean autoDownload;
+ Boolean disableChecksums;
+ Map systemProperties;
+
+ public SourceUnit getSourceUnit() {
+ return sourceUnit;
+ }
+
+ public void setCompilationUnit(final CompilationUnit compilationUnit) {
+ this.compilationUnit = compilationUnit;
+ }
+
+ public void visit(ASTNode[] nodes, SourceUnit source) {
+ sourceUnit = source;
+ loader = null;
+ initContextClassLoader = false;
+
+ ModuleNode mn = (ModuleNode) nodes[0];
+
+ allowShortGrab = true;
+ allowShortGrabExcludes = true;
+ allowShortGrabConfig = true;
+ allowShortGrapes = true;
+ allowShortGrabResolver = true;
+ grabAliases = new HashSet();
+ grabExcludeAliases = new HashSet();
+ grabConfigAliases = new HashSet();
+ grapesAliases = new HashSet();
+ grabResolverAliases = new HashSet();
+ for (ImportNode im : mn.getImports()) {
+ String alias = im.getAlias();
+ String className = im.getClassName();
+ if ((className.endsWith(GRAB_DOT_NAME) && ((alias == null) || (alias.length() == 0)))
+ || (GRAB_CLASS_NAME.equals(alias)))
+ {
+ allowShortGrab = false;
+ } else if (GRAB_CLASS_NAME.equals(className)) {
+ grabAliases.add(im.getAlias());
+ }
+ if ((className.endsWith(GRAPES_DOT_NAME) && ((alias == null) || (alias.length() == 0)))
+ || (GRAPES_CLASS_NAME.equals(alias)))
+ {
+ allowShortGrapes = false;
+ } else if (GRAPES_CLASS_NAME.equals(className)) {
+ grapesAliases.add(im.getAlias());
+ }
+ if ((className.endsWith(GRABRESOLVER_DOT_NAME) && ((alias == null) || (alias.length() == 0)))
+ || (GRABRESOLVER_CLASS_NAME.equals(alias)))
+ {
+ allowShortGrabResolver = false;
+ } else if (GRABRESOLVER_CLASS_NAME.equals(className)) {
+ grabResolverAliases.add(im.getAlias());
+ }
+ }
+
+ // GRECLIPSE - if this is a list and not a set then you can duplicates when multiple classes
+ // are visited in the same source file. The same grabs are accumulated. There is maybe a
+ // better fix but this is easy. If there are duplicates it will work but we are calling
+ // grab with unnecessary dup info.
+ Collection> grabMaps = new LinkedHashSet>();
+ List> grabMapsInit = new ArrayList>();
+ List> grabExcludeMaps = new ArrayList>();
+
+ for (ClassNode classNode : sourceUnit.getAST().getClasses()) {
+ grabAnnotations = new ArrayList();
+ grabExcludeAnnotations = new ArrayList();
+ grabConfigAnnotations = new ArrayList();
+ grapesAnnotations = new ArrayList();
+ grabResolverAnnotations = new ArrayList();
+
+ visitClass(classNode);
+
+ ClassNode grapeClassNode = ClassHelper.make(Grape.class);
+
+ List grabResolverInitializers = new ArrayList();
+
+ if (!grapesAnnotations.isEmpty()) {
+ for (AnnotationNode node : grapesAnnotations) {
+ Expression init = node.getMember("initClass");
+ Expression value = node.getMember("value");
+ if (value instanceof ListExpression) {
+ for (Object o : ((ListExpression)value).getExpressions()) {
+ if (o instanceof ConstantExpression) {
+ extractGrab(init, (ConstantExpression) o);
+ }
+ }
+ } else if (value instanceof ConstantExpression) {
+ extractGrab(init, (ConstantExpression) value);
+ }
+ // don't worry if it's not a ListExpression, or AnnotationConstant, etc.
+ // the rest of GroovyC will flag it as a syntax error later, so we don't
+ // need to raise the error ourselves
+ }
+ }
+
+ if (!grabResolverAnnotations.isEmpty()) {
+ grabResolverAnnotationLoop:
+ for (AnnotationNode node : grabResolverAnnotations) {
+ Map grabResolverMap = new HashMap();
+ String sval = getMemberStringValue(node, "value");
+ if (sval != null && sval.length() > 0) {
+ for (String s : GRABRESOLVER_REQUIRED) {
+ String mval = getMemberStringValue(node, s);
+ if (mval != null && mval.isEmpty()) mval = null;
+ if (mval != null) {
+ addError("The attribute \"" + s + "\" conflicts with attribute 'value' in @" + node.getClassNode().getNameWithoutPackage() + " annotations", node);
+ continue grabResolverAnnotationLoop;
+ }
+ }
+ grabResolverMap.put("name", sval);
+ grabResolverMap.put("root", sval);
+ } else {
+ for (String s : GRABRESOLVER_REQUIRED) {
+ String mval = getMemberStringValue(node, s);
+ Expression member = node.getMember(s);
+ if (member == null || (mval != null && mval.isEmpty())) {
+ addError("The missing attribute \"" + s + "\" is required in @" + node.getClassNode().getNameWithoutPackage() + " annotations", node);
+ continue grabResolverAnnotationLoop;
+ } else if (mval == null) {
+ addError("Attribute \"" + s + "\" has value " + member.getText() + " but should be an inline constant String in @" + node.getClassNode().getNameWithoutPackage() + " annotations", node);
+ continue grabResolverAnnotationLoop;
+ }
+ grabResolverMap.put(s, mval);
+ }
+ }
+
+ // If no scheme is specified for the repository root,
+ // then turn it into a URI relative to that of the source file.
+ String root = (String) grabResolverMap.get("root");
+ if (root != null && !root.contains(":")) {
+ URI sourceURI = null;
+ // Since we use the data: scheme for StringReaderSources (which are fairly common)
+ // and those are not hierarchical we can't use them for making an absolute URI.
+ if (!(getSourceUnit().getSource() instanceof StringReaderSource)) {
+ // Otherwise let's trust the source to know where it is from.
+ // And actually InputStreamReaderSource doesn't know what to do and so returns null.
+ sourceURI = getSourceUnit().getSource().getURI();
+ }
+ // If source doesn't know how to get a reference to itself,
+ // then let's use the current working directory, since the repo can be relative to that.
+ if (sourceURI == null) {
+ sourceURI = new File(".").toURI();
+ }
+ try {
+ URI rootURI = sourceURI.resolve(new URI(root));
+ grabResolverMap.put("root", rootURI.toString());
+ } catch (URISyntaxException e) {
+ // We'll be silent here.
+ // If the URI scheme is unknown or not hierarchical, then we just can't help them and shouldn't cause any trouble either.
+ // addError("Attribute \"root\" has value '" + root + "' which can't be turned into a valid URI relative to it's source '" + getSourceUnit().getName() + "' @" + node.getClassNode().getNameWithoutPackage() + " annotations", node);
+ }
+ }
+
+ Grape.addResolver(grabResolverMap);
+ addGrabResolverAsStaticInitIfNeeded(grapeClassNode, node, grabResolverInitializers, grabResolverMap);
+ }
+ }
+
+ if (!grabConfigAnnotations.isEmpty()) {
+ for (AnnotationNode node : grabConfigAnnotations) {
+ checkForClassLoader(node);
+ checkForInitContextClassLoader(node);
+ checkForAutoDownload(node);
+ checkForSystemProperties(node);
+ checkForDisableChecksums(node);
+ }
+ addInitContextClassLoaderIfNeeded(classNode);
+ }
+
+ if (!grabExcludeAnnotations.isEmpty()) {
+ grabExcludeAnnotationLoop:
+ for (AnnotationNode node : grabExcludeAnnotations) {
+ Map grabExcludeMap = new HashMap();
+ checkForConvenienceForm(node, true);
+ for (String s : GRABEXCLUDE_REQUIRED) {
+ Expression member = node.getMember(s);
+ if (member == null) {
+ addError("The missing attribute \"" + s + "\" is required in @" + node.getClassNode().getNameWithoutPackage() + " annotations", node);
+ continue grabExcludeAnnotationLoop;
+ } else if (!(member instanceof ConstantExpression)) {
+ addError("Attribute \"" + s + "\" has value " + member.getText() + " but should be an inline constant in @" + node.getClassNode().getNameWithoutPackage() + " annotations", node);
+ continue grabExcludeAnnotationLoop;
+ }
+ grabExcludeMap.put(s, ((ConstantExpression)member).getValue());
+ }
+ grabExcludeMaps.add(grabExcludeMap);
+ }
+ }
+
+ if (!grabAnnotations.isEmpty()) {
+ grabAnnotationLoop:
+ for (AnnotationNode node : grabAnnotations) {
+ Map grabMap = new HashMap();
+ checkForConvenienceForm(node, false);
+ for (String s : GRAB_ALL) {
+ Expression member = node.getMember(s);
+ String mval = getMemberStringValue(node, s);
+ if (mval != null && mval.isEmpty()) member = null;
+ if (member == null && !GRAB_OPTIONAL.contains(s)) {
+ addError("The missing attribute \"" + s + "\" is required in @" + node.getClassNode().getNameWithoutPackage() + " annotations", node);
+ continue grabAnnotationLoop;
+ } else if (member != null && !(member instanceof ConstantExpression)) {
+ addError("Attribute \"" + s + "\" has value " + member.getText() + " but should be an inline constant in @" + node.getClassNode().getNameWithoutPackage() + " annotations", node);
+ continue grabAnnotationLoop;
+ }
+ if (node.getMember(s) != null) {
+ grabMap.put(s, ((ConstantExpression)member).getValue());
+ }
+ }
+ grabMaps.add(grabMap);
+ if ((node.getMember("initClass") == null) || (node.getMember("initClass") == ConstantExpression.TRUE)) {
+ grabMapsInit.add(grabMap);
+ }
+ }
+ callGrabAsStaticInitIfNeeded(classNode, grapeClassNode, grabMapsInit, grabExcludeMaps);
+ }
+
+ if (!grabResolverInitializers.isEmpty()) {
+ classNode.addStaticInitializerStatements(grabResolverInitializers, true);
+ }
+ }
+
+ if (!grabMaps.isEmpty()) {
+ Map basicArgs = new HashMap();
+ basicArgs.put("classLoader", loader != null ? loader : sourceUnit.getClassLoader());
+ if (!grabExcludeMaps.isEmpty()) basicArgs.put("excludes", grabExcludeMaps);
+ if (autoDownload != null) basicArgs.put(AUTO_DOWNLOAD_SETTING, autoDownload);
+ if (disableChecksums != null) basicArgs.put(DISABLE_CHECKSUMS_SETTING, disableChecksums);
+ if (systemProperties != null) basicArgs.put(SYSTEM_PROPERTIES_SETTING, systemProperties);
+
+ // GRECLIPSE edit
+ /*try {
+ Grape.grab(basicArgs, grabMaps.toArray(new Map[grabMaps.size()]));
+ // grab may have added more transformations through new URLs added to classpath, so do one more scan
+ if (compilationUnit!=null) {
+ ASTTransformationVisitor.addGlobalTransformsAfterGrab(compilationUnit.getASTTransformationsContext());
+ }
+ } catch (RuntimeException re) {
+ // Decided against syntax exception since this is not a syntax error.
+ // The down side is we lose line number information for the offending
+ // @Grab annotation.
+ source.addException(re);
+ }*/
+ // grab one thing at a time (so the errors are discovered individually)
+ Map[] grabMapsAsMapArray = grabMaps.toArray(new Map[grabMaps.size()]);
+ for (int i = 0, n = grabMapsAsMapArray.length; i < n; i += 1) {
+ try {
+ Grape.grab(new HashMap(basicArgs), grabMapsAsMapArray[i]);
+ // grab may have added more transformations through new URLs added to classpath, so do one more scan
+ if (compilationUnit != null) {
+ ASTTransformationVisitor.addGlobalTransformsAfterGrab(compilationUnit.getASTTransformationsContext());
+ }
+ } catch (RuntimeException re) {
+ // Error grabbing Grapes -- [unresolved dependency: joda-timxxe#joda-time;1.6: not found]
+ String msg = re.getMessage();
+ if (grabAnnotations.size() > i) {
+ addError(msg, grabAnnotations.get(i));
+ } else {
+ source.addException(re);
+ }
+ }
+ }
+ // GRECLIPSE end
+ }
+ }
+
+ private void callGrabAsStaticInitIfNeeded(ClassNode classNode, ClassNode grapeClassNode, List> grabMapsInit, List> grabExcludeMaps) {
+ List grabInitializers = new ArrayList();
+ MapExpression basicArgs = new MapExpression();
+ if (autoDownload != null) {
+ basicArgs.addMapEntryExpression(constX(AUTO_DOWNLOAD_SETTING), constX(autoDownload));
+ }
+
+ if (disableChecksums != null) {
+ basicArgs.addMapEntryExpression(constX(DISABLE_CHECKSUMS_SETTING), constX(disableChecksums));
+ }
+
+ if (systemProperties != null && !systemProperties.isEmpty()) {
+ BlockStatement block = new BlockStatement();
+ for(Map.Entry e : systemProperties.entrySet()) {
+ block.addStatement(stmt(callX(SYSTEM_CLASSNODE, "setProperty", args(constX(e.getKey()), constX(e.getValue())))));
+ }
+ StaticMethodCallExpression enabled = callX(SYSTEM_CLASSNODE, "getProperty", args(constX("groovy.grape.enable"), constX("true")));
+ grabInitializers.add(ifS(eqX(enabled, constX("true")), block));
+ }
+
+ if (!grabExcludeMaps.isEmpty()) {
+ ListExpression list = new ListExpression();
+ for (Map map : grabExcludeMaps) {
+ Set> entries = map.entrySet();
+ MapExpression inner = new MapExpression();
+ for (Map.Entry entry : entries) {
+ inner.addMapEntryExpression(constX(entry.getKey()), constX(entry.getValue()));
+ }
+ list.addExpression(inner);
+ }
+ basicArgs.addMapEntryExpression(constX("excludes"), list);
+ }
+
+ List argList = new ArrayList();
+ argList.add(basicArgs);
+ if (grabMapsInit.isEmpty()) return;
+ for (Map grabMap : grabMapsInit) {
+ // add Grape.grab(excludeArgs, [group:group, module:module, version:version, classifier:classifier])
+ // or Grape.grab([group:group, module:module, version:version, classifier:classifier])
+ MapExpression dependencyArg = new MapExpression();
+ for (String s : GRAB_REQUIRED) {
+ dependencyArg.addMapEntryExpression(constX(s), constX(grabMap.get(s)));
+ }
+ for (String s : GRAB_OPTIONAL) {
+ if (grabMap.containsKey(s))
+ dependencyArg.addMapEntryExpression(constX(s), constX(grabMap.get(s)));
+ }
+ argList.add(dependencyArg);
+ }
+ grabInitializers.add(stmt(callX(grapeClassNode, "grab", args(argList))));
+
+ // insert at beginning so we have the classloader set up before the class is called
+ classNode.addStaticInitializerStatements(grabInitializers, true);
+ }
+
+ private static void addGrabResolverAsStaticInitIfNeeded(ClassNode grapeClassNode, AnnotationNode node,
+ List grabResolverInitializers, Map grabResolverMap) {
+ if ((node.getMember("initClass") == null)
+ || (node.getMember("initClass") == ConstantExpression.TRUE))
+ {
+ MapExpression resolverArgs = new MapExpression();
+ for (Map.Entry next : grabResolverMap.entrySet()) {
+ resolverArgs.addMapEntryExpression(constX(next.getKey()), constX(next.getValue()));
+ }
+ grabResolverInitializers.add(stmt(callX(grapeClassNode, "addResolver", args(resolverArgs))));
+ }
+ }
+
+ private void addInitContextClassLoaderIfNeeded(ClassNode classNode) {
+ if (initContextClassLoader) {
+ Statement initStatement = stmt(callX(
+ callX(THREAD_CLASSNODE, "currentThread"),
+ "setContextClassLoader",
+ callX(callThisX("getClass"), "getClassLoader")
+ )
+ );
+ classNode.addObjectInitializerStatements(initStatement);
+ }
+ }
+
+ private void checkForClassLoader(AnnotationNode node) {
+ Object val = node.getMember("systemClassLoader");
+ if (val == null || !(val instanceof ConstantExpression)) return;
+ Object systemClassLoaderObject = ((ConstantExpression)val).getValue();
+ if (!(systemClassLoaderObject instanceof Boolean)) return;
+ Boolean systemClassLoader = (Boolean) systemClassLoaderObject;
+ if (systemClassLoader) loader = ClassLoader.getSystemClassLoader();
+ }
+
+ private void checkForInitContextClassLoader(AnnotationNode node) {
+ Object val = node.getMember("initContextClassLoader");
+ if (val == null || !(val instanceof ConstantExpression)) return;
+ Object initContextClassLoaderObject = ((ConstantExpression)val).getValue();
+ if (!(initContextClassLoaderObject instanceof Boolean)) return;
+ initContextClassLoader = (Boolean) initContextClassLoaderObject;
+ }
+
+ private void checkForAutoDownload(AnnotationNode node) {
+ Object val = node.getMember(AUTO_DOWNLOAD_SETTING);
+ if (val == null || !(val instanceof ConstantExpression)) return;
+ Object autoDownloadValue = ((ConstantExpression)val).getValue();
+ if (!(autoDownloadValue instanceof Boolean)) return;
+ autoDownload = (Boolean) autoDownloadValue;
+ }
+
+ private void checkForDisableChecksums(AnnotationNode node) {
+ Object val = node.getMember(DISABLE_CHECKSUMS_SETTING);
+ if (val == null || !(val instanceof ConstantExpression)) return;
+ Object disableChecksumsValue = ((ConstantExpression)val).getValue();
+ if (!(disableChecksumsValue instanceof Boolean)) return;
+ disableChecksums = (Boolean) disableChecksumsValue;
+ }
+
+ private void checkForSystemProperties(AnnotationNode node) {
+ systemProperties = new HashMap();
+ List nameValueList = AbstractASTTransformation.getMemberStringList(node, SYSTEM_PROPERTIES_SETTING);
+ if (nameValueList != null) {
+ for (String nameValue : nameValueList) {
+ int equalsDelim = nameValue.indexOf('=');
+ if (equalsDelim != -1) {
+ systemProperties.put(nameValue.substring(0, equalsDelim), nameValue.substring(equalsDelim + 1));
+ }
+ }
+ }
+ }
+
+ private static void checkForConvenienceForm(AnnotationNode node, boolean exclude) {
+ Object val = node.getMember("value");
+ if (val == null || !(val instanceof ConstantExpression)) return;
+ Object allParts = ((ConstantExpression)val).getValue();
+ if (!(allParts instanceof String)) return;
+ String allstr = (String) allParts;
+
+ // strip off trailing attributes
+ boolean done = false;
+ while (!done) {
+ Matcher attrs = ATTRIBUTES_PATTERN.matcher(allstr);
+ if (attrs.find()) {
+ String attrName = attrs.group(2);
+ String attrValue = attrs.group(3);
+ if (attrName == null || attrValue == null) continue;
+ boolean isBool = GRAB_BOOLEAN.contains(attrName);
+ ConstantExpression value = constX(isBool ? Boolean.valueOf(attrValue) : attrValue);
+ value.setSourcePosition(node);
+ node.addMember(attrName, value);
+ int lastSemi = allstr.lastIndexOf(';');
+ if (lastSemi == -1) {
+ allstr = "";
+ break;
+ }
+ allstr = allstr.substring(0, lastSemi);
+ } else {
+ done = true;
+ }
+ }
+
+ if (allstr.contains("#")) {
+ // see: http://ant.apache.org/ivy/history/latest-milestone/textual.html
+ Matcher m = IVY_PATTERN.matcher(allstr);
+ if (!m.find()) return;
+ if (m.group(1) == null || m.group(2) == null) return;
+ node.addMember("module", constX(m.group(2)));
+ node.addMember("group", constX(m.group(1)));
+ if (m.group(6) != null) node.addMember("conf", constX(m.group(6)));
+ if (m.group(4) != null) node.addMember("version", constX(m.group(4)));
+ else if (!exclude && node.getMember("version") == null) node.addMember("version", constX("*"));
+ node.getMembers().remove("value");
+ } else if (allstr.contains(":")) {
+ // assume gradle syntax
+ // see: http://www.gradle.org/latest/docs/userguide/dependency_management.html#sec:how_to_declare_your_dependencies
+ Map parts = GrapeUtil.getIvyParts(allstr);
+ for (Map.Entry entry : parts.entrySet()) {
+ String key = entry.getKey();
+ String value = entry.getValue().toString();
+ if (!key.equals("version") || !value.equals("*") || !exclude) {
+ node.addMember(key, constX(value));
+ }
+ }
+ node.getMembers().remove("value");
+ }
+ }
+
+ private void extractGrab(Expression init, ConstantExpression ce) {
+ if (ce.getValue() instanceof AnnotationNode) {
+ AnnotationNode annotation = (AnnotationNode) ce.getValue();
+ if ((init != null) && (annotation.getMember("initClass") != null)) {
+ annotation.setMember("initClass", init);
+ }
+ String name = annotation.getClassNode().getName();
+ if ((GRAB_CLASS_NAME.equals(name))
+ || (allowShortGrab && GRAB_SHORT_NAME.equals(name))
+ || (grabAliases.contains(name))) {
+ grabAnnotations.add(annotation);
+ }
+ if ((GRABEXCLUDE_CLASS_NAME.equals(name))
+ || (allowShortGrabExcludes && GRABEXCLUDE_SHORT_NAME.equals(name))
+ || (grabExcludeAliases.contains(name))) {
+ grabExcludeAnnotations.add(annotation);
+ }
+ if ((GRABCONFIG_CLASS_NAME.equals(name))
+ || (allowShortGrabConfig && GRABCONFIG_SHORT_NAME.equals(name))
+ || (grabConfigAliases.contains(name))) {
+ grabConfigAnnotations.add(annotation);
+ }
+ if ((GRABRESOLVER_CLASS_NAME.equals(name))
+ || (allowShortGrabResolver && GRABRESOLVER_SHORT_NAME.equals(name))
+ || (grabResolverAliases.contains(name))) {
+ grabResolverAnnotations.add(annotation);
+ }
+ }
+ }
+
+ /**
+ * Adds the annotation to the internal target list if a match is found.
+ *
+ * @param node the AST node we are processing
+ */
+ public void visitAnnotations(AnnotatedNode node) {
+ super.visitAnnotations(node);
+ for (AnnotationNode an : node.getAnnotations()) {
+ String name = an.getClassNode().getName();
+ if ((GRAB_CLASS_NAME.equals(name))
+ || (allowShortGrab && GRAB_SHORT_NAME.equals(name))
+ || (grabAliases.contains(name))) {
+ grabAnnotations.add(an);
+ }
+ if ((GRABEXCLUDE_CLASS_NAME.equals(name))
+ || (allowShortGrabExcludes && GRABEXCLUDE_SHORT_NAME.equals(name))
+ || (grabExcludeAliases.contains(name))) {
+ grabExcludeAnnotations.add(an);
+ }
+ if ((GRABCONFIG_CLASS_NAME.equals(name))
+ || (allowShortGrabConfig && GRABCONFIG_SHORT_NAME.equals(name))
+ || (grabConfigAliases.contains(name))) {
+ grabConfigAnnotations.add(an);
+ }
+ if ((GRAPES_CLASS_NAME.equals(name))
+ || (allowShortGrapes && GRAPES_SHORT_NAME.equals(name))
+ || (grapesAliases.contains(name))) {
+ grapesAnnotations.add(an);
+ }
+ if ((GRABRESOLVER_CLASS_NAME.equals(name))
+ || (allowShortGrabResolver && GRABRESOLVER_SHORT_NAME.equals(name))
+ || (grabResolverAliases.contains(name))) {
+ grabResolverAnnotations.add(an);
+ }
+ }
+ }
+
+}
diff --git a/base/org.codehaus.groovy26/src/groovy/grape/GrapeIvy.groovy b/base/org.codehaus.groovy26/src/groovy/grape/GrapeIvy.groovy
new file mode 100644
index 0000000000..d70915b31d
--- /dev/null
+++ b/base/org.codehaus.groovy26/src/groovy/grape/GrapeIvy.groovy
@@ -0,0 +1,730 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package groovy.grape
+
+import org.apache.groovy.plugin.GroovyRunner
+import org.apache.groovy.plugin.GroovyRunnerRegistry
+import org.apache.ivy.Ivy
+import org.apache.ivy.core.cache.ResolutionCacheManager
+import org.apache.ivy.core.event.IvyListener
+import org.apache.ivy.core.event.download.PrepareDownloadEvent
+import org.apache.ivy.core.event.resolve.StartResolveEvent
+import org.apache.ivy.core.module.descriptor.Configuration
+import org.apache.ivy.core.module.descriptor.DefaultDependencyArtifactDescriptor
+import org.apache.ivy.core.module.descriptor.DefaultDependencyDescriptor
+import org.apache.ivy.core.module.descriptor.DefaultExcludeRule
+import org.apache.ivy.core.module.descriptor.DefaultModuleDescriptor
+import org.apache.ivy.core.module.id.ArtifactId
+import org.apache.ivy.core.module.id.ModuleId
+import org.apache.ivy.core.module.id.ModuleRevisionId
+import org.apache.ivy.core.report.ArtifactDownloadReport
+import org.apache.ivy.core.report.ResolveReport
+import org.apache.ivy.core.resolve.ResolveOptions
+import org.apache.ivy.core.settings.IvySettings
+import org.apache.ivy.plugins.matcher.ExactPatternMatcher
+import org.apache.ivy.plugins.matcher.PatternMatcher
+import org.apache.ivy.plugins.resolver.ChainResolver
+import org.apache.ivy.plugins.resolver.IBiblioResolver
+import org.apache.ivy.util.DefaultMessageLogger
+import org.apache.ivy.util.Message
+import org.codehaus.groovy.reflection.CachedClass
+import org.codehaus.groovy.reflection.ClassInfo
+import org.codehaus.groovy.reflection.ReflectionUtils
+import org.codehaus.groovy.runtime.m12n.ExtensionModuleScanner
+import org.codehaus.groovy.runtime.metaclass.MetaClassRegistryImpl
+
+import javax.xml.parsers.DocumentBuilderFactory
+import java.util.jar.JarFile
+import java.util.regex.Pattern
+import java.util.zip.ZipEntry
+import java.util.zip.ZipException
+import java.util.zip.ZipFile
+
+/**
+ * Implementation suppoting {@code @Grape} and {@code @Grab} annotations based on Ivy.
+ */
+class GrapeIvy implements GrapeEngine {
+
+ static final int DEFAULT_DEPTH = 3
+
+ private static final String METAINF_PREFIX = 'META-INF/services/'
+ private static final String RUNNER_PROVIDER_CONFIG = GroovyRunner.class.getName()
+
+ private final exclusiveGrabArgs = [
+ ['group', 'groupId', 'organisation', 'organization', 'org'],
+ ['module', 'artifactId', 'artifact'],
+ ['version', 'revision', 'rev'],
+ ['conf', 'scope', 'configuration'],
+ ].inject([:], {m, g -> g.each {a -> m[a] = (g - a) as Set}; m})
+
+ boolean enableGrapes
+ Ivy ivyInstance
+ Set resolvedDependencies
+ Set downloadedArtifacts
+ // weak hash map so we don't leak loaders directly
+ Map> loadedDeps = new WeakHashMap>()
+ // set that stores the IvyGrabRecord(s) for all the dependencies in each grab() call
+ Set grabRecordsForCurrDependencies = new LinkedHashSet()
+ // we keep the settings so that addResolver can add to the resolver chain
+ IvySettings settings
+
+ public GrapeIvy() {
+ // if we are already initialized, quit
+ if (enableGrapes) return
+
+ // start ivy
+ Message.defaultLogger = new DefaultMessageLogger(System.getProperty("ivy.message.logger.level", "-1") as int)
+ settings = new IvySettings()
+
+ // configure settings
+ def grapeConfig = getLocalGrapeConfig()
+ if (!grapeConfig.exists()) {
+ grapeConfig = GrapeIvy.getResource("defaultGrapeConfig.xml")
+ }
+ try {
+ settings.load(grapeConfig) // exploit multi-methods for convenience
+ } catch (java.text.ParseException ex) {
+ def configLocation = grapeConfig instanceof File ? grapeConfig.canonicalPath : grapeConfig.toString()
+ System.err.println "Local Ivy config file '$configLocation' appears corrupt - ignoring it and using default config instead\nError was: " + ex.message
+ grapeConfig = GrapeIvy.getResource("defaultGrapeConfig.xml")
+ settings.load(grapeConfig)
+ }
+
+ // set up the cache dirs
+ settings.defaultCache = getGrapeCacheDir()
+
+ settings.setVariable("ivy.default.configuration.m2compatible", "true")
+ ivyInstance = Ivy.newInstance(settings)
+ org.apache.ivy.core.IvyContext.getContext().setIvy(ivyInstance);
+ resolvedDependencies = []
+ downloadedArtifacts = []
+
+ //TODO add grab to the DGM??
+
+ enableGrapes = true
+ }
+
+ public File getGroovyRoot() {
+ String root = System.getProperty("groovy.root")
+ def groovyRoot
+ if (root == null) {
+ groovyRoot = new File(System.getProperty("user.home"), ".groovy")
+ } else {
+ groovyRoot = new File(root)
+ }
+ try {
+ groovyRoot = groovyRoot.canonicalFile
+ } catch (IOException e) {
+ // skip canonicalization then, it may not exist yet
+ }
+ return groovyRoot
+ }
+
+ public File getLocalGrapeConfig() {
+ String grapeConfig = System.getProperty("grape.config")
+ if(grapeConfig) {
+ return new File(grapeConfig)
+ }
+ return new File(getGrapeDir(), 'grapeConfig.xml')
+ }
+
+ public File getGrapeDir() {
+ String root = System.getProperty("grape.root")
+ if(root == null) {
+ return getGroovyRoot()
+ }
+ File grapeRoot = new File(root)
+ try {
+ grapeRoot = grapeRoot.canonicalFile
+ } catch (IOException e) {
+ // skip canonicalization then, it may not exist yet
+ }
+ return grapeRoot
+ }
+
+ public File getGrapeCacheDir() {
+ File cache = new File(getGrapeDir(), 'grapes')
+ if (!cache.exists()) {
+ cache.mkdirs()
+ } else if (!cache.isDirectory()) {
+ throw new RuntimeException("The grape cache dir $cache is not a directory")
+ }
+ return cache
+ }
+
+ public def chooseClassLoader(Map args) {
+ def loader = args.classLoader
+ if (!isValidTargetClassLoader(loader)) {
+ loader = (args.refObject?.class
+ ?:ReflectionUtils.getCallingClass(args.calleeDepth?:1)
+ )?.classLoader
+ while (loader && !isValidTargetClassLoader(loader)) {
+ loader = loader.parent
+ }
+ //if (!isValidTargetClassLoader(loader)) {
+ // loader = Thread.currentThread().contextClassLoader
+ //}
+ //if (!isValidTargetClassLoader(loader)) {
+ // loader = GrapeIvy.class.classLoader
+ //}
+ /* GRECLIPSE edit -- don't check this. Removing this check will only affect our copy of GrapeIvy that is used during compilation where the classloader does not matter.
+ if (!isValidTargetClassLoader(loader)) {
+ throw new RuntimeException("No suitable ClassLoader found for grab")
+ }
+ */
+ }
+ return loader
+ }
+
+ private boolean isValidTargetClassLoader(loader) {
+ return isValidTargetClassLoaderClass(loader?.class)
+ }
+
+ private boolean isValidTargetClassLoaderClass(Class loaderClass) {
+ return (loaderClass != null) &&
+ (
+ (loaderClass.name == 'groovy.lang.GroovyClassLoader') ||
+ (loaderClass.name == 'org.codehaus.groovy.tools.RootLoader') ||
+ isValidTargetClassLoaderClass(loaderClass.superclass)
+ )
+ }
+
+ public IvyGrabRecord createGrabRecord(Map deps) {
+ // parse the actual dependency arguments
+ String module = deps.module ?: deps.artifactId ?: deps.artifact
+ if (!module) {
+ throw new RuntimeException('grab requires at least a module: or artifactId: or artifact: argument')
+ }
+
+ String groupId = deps.group ?: deps.groupId ?: deps.organisation ?: deps.organization ?: deps.org ?: ''
+ String ext = deps.ext ?: deps.type ?: ''
+ String type = deps.type ?: ''
+
+ //TODO accept ranges and decode them? except '1.0.0'..<'2.0.0' won't work in groovy
+ String version = deps.version ?: deps.revision ?: deps.rev ?: '*'
+ if ('*' == version) version = 'latest.default'
+
+ ModuleRevisionId mrid = ModuleRevisionId.newInstance(groupId, module, version)
+
+ boolean force = deps.containsKey('force') ? deps.force : true
+ boolean changing = deps.containsKey('changing') ? deps.changing : false
+ boolean transitive = deps.containsKey('transitive') ? deps.transitive : true
+ def conf = deps.conf ?: deps.scope ?: deps.configuration ?: ['default']
+ if (conf instanceof String) {
+ if (conf.startsWith("[") && conf.endsWith("]")) conf = conf[1..-2]
+ conf = conf.split(",").toList()
+ }
+ def classifier = deps.classifier ?: null
+
+ return new IvyGrabRecord(mrid:mrid, conf:conf, changing:changing, transitive:transitive, force:force, classifier:classifier, ext:ext, type:type)
+ }
+
+ public grab(String endorsedModule) {
+ return grab(group:'groovy.endorsed', module:endorsedModule, version:GroovySystem.version)
+ }
+
+ public grab(Map args) {
+ args.calleeDepth = args.calleeDepth?:DEFAULT_DEPTH + 1
+ return grab(args, args)
+ }
+
+ public grab(Map args, Map... dependencies) {
+ ClassLoader loader = null
+ grabRecordsForCurrDependencies.clear()
+
+ try {
+ // identify the target classloader early, so we fail before checking repositories
+ loader = chooseClassLoader(
+ classLoader:args.remove('classLoader'),
+ refObject:args.remove('refObject'),
+ calleeDepth:args.calleeDepth?:DEFAULT_DEPTH,
+ )
+
+ // check for non-fail null.
+ // If we were in fail mode we would have already thrown an exception
+ if (!loader) return
+
+ def uris = resolve(loader, args, dependencies)
+ for (URI uri in uris) {
+ loader.addURL(uri.toURL())
+ }
+ boolean runnerServicesFound = false
+ for (URI uri in uris) {
+ //TODO check artifact type, jar vs library, etc
+ File file = new File(uri)
+ processCategoryMethods(loader, file)
+ Collection services = processMetaInfServices(loader, file)
+ if (!runnerServicesFound) {
+ runnerServicesFound = services.contains(RUNNER_PROVIDER_CONFIG)
+ }
+ }
+ if (runnerServicesFound) {
+ GroovyRunnerRegistry.getInstance().load(loader)
+ }
+ } catch (Exception e) {
+ // clean-up the state first
+ Set grabRecordsForCurrLoader = getLoadedDepsForLoader(loader)
+ grabRecordsForCurrLoader.removeAll(grabRecordsForCurrDependencies)
+ grabRecordsForCurrDependencies.clear()
+
+ if (args.noExceptions) {
+ return e
+ }
+ throw e
+ }
+ return null
+ }
+
+ private processCategoryMethods(ClassLoader loader, File file) {
+ // register extension methods if jar
+ if (file.name.toLowerCase().endsWith(".jar")) {
+ def mcRegistry = GroovySystem.metaClassRegistry
+ if (mcRegistry instanceof MetaClassRegistryImpl) {
+ try {
+ JarFile jar = new JarFile(file)
+ def entry = jar.getEntry(ExtensionModuleScanner.MODULE_META_INF_FILE)
+ if (entry) {
+ Properties props = new Properties()
+ props.load(jar.getInputStream(entry))
+ Map> metaMethods = new HashMap>()
+ mcRegistry.registerExtensionModuleFromProperties(props, loader, metaMethods)
+ // add old methods to the map
+ metaMethods.each { CachedClass c, List methods ->
+ // GROOVY-5543: if a module was loaded using grab, there are chances that subclasses
+ // have their own ClassInfo, and we must change them as well!
+ Set classesToBeUpdated = [c]
+ ClassInfo.onAllClassInfo { ClassInfo info ->
+ if (c.theClass.isAssignableFrom(info.cachedClass.theClass)) {
+ classesToBeUpdated << info.cachedClass
+ }
+ }
+ classesToBeUpdated*.addNewMopMethods(methods)
+ }
+ }
+ }
+ catch(ZipException zipException) {
+ throw new RuntimeException("Grape could not load jar '$file'", zipException)
+ }
+ }
+ }
+ }
+
+ void processOtherServices(ClassLoader loader, File f) {
+ processMetaInfServices(loader, f) // ignore result
+ }
+
+ /**
+ * Searches the given File for known service provider
+ * configuration files to process.
+ *
+ * @param loader used to locate service provider files
+ * @param f ZipFile in which to search for services
+ * @return a collection of service provider files that were found
+ */
+ private Collection processMetaInfServices(ClassLoader loader, File f) {
+ List services = new ArrayList<>()
+ try {
+ ZipFile zf = new ZipFile(f)
+ String providerConfig = 'org.codehaus.groovy.runtime.SerializedCategoryMethods'
+ ZipEntry serializedCategoryMethods = zf.getEntry(METAINF_PREFIX + providerConfig)
+ if (serializedCategoryMethods != null) {
+ services.add(providerConfig)
+ processSerializedCategoryMethods(zf.getInputStream(serializedCategoryMethods))
+ }
+ // TODO: remove in a future release (replaced by GroovyRunnerRegistry)
+ providerConfig = 'org.codehaus.groovy.plugins.Runners'
+ ZipEntry pluginRunners = zf.getEntry(METAINF_PREFIX + providerConfig)
+ if (pluginRunners != null) {
+ services.add(providerConfig)
+ processRunners(zf.getInputStream(pluginRunners), f.getName(), loader)
+ }
+ // GroovyRunners are loaded per ClassLoader using a ServiceLoader so here
+ // it only needs to be indicated that the service provider file was found
+ if (zf.getEntry(METAINF_PREFIX + RUNNER_PROVIDER_CONFIG) != null) {
+ services.add(RUNNER_PROVIDER_CONFIG)
+ }
+ } catch(ZipException ignore) {
+ // ignore files we can't process, e.g. non-jar/zip artifacts
+ // TODO log a warning
+ }
+ return services
+ }
+
+ void processSerializedCategoryMethods(InputStream is) {
+ is.text.readLines().each {
+ println it.trim() // TODO implement this or delete it
+ }
+ }
+
+ void processRunners(InputStream is, String name, ClassLoader loader) {
+ GroovyRunnerRegistry registry = GroovyRunnerRegistry.getInstance()
+ is.text.readLines()*.trim().findAll{ !it.isEmpty() && it[0] != '#' }.each {
+ try {
+ registry[name] = loader.loadClass(it).newInstance()
+ } catch (Exception ex) {
+ throw new IllegalStateException("Error registering runner class '" + it + "'", ex)
+ }
+ }
+ }
+
+ public ResolveReport getDependencies(Map args, IvyGrabRecord... grabRecords) {
+ ResolutionCacheManager cacheManager = ivyInstance.resolutionCacheManager
+
+ def millis = System.currentTimeMillis()
+ def md = new DefaultModuleDescriptor(ModuleRevisionId
+ .newInstance("caller", "all-caller", "working" + millis.toString()[-2..-1]), "integration", null, true)
+ md.addConfiguration(new Configuration('default'))
+ md.setLastModified(millis)
+
+ addExcludesIfNeeded(args, md)
+
+ for (IvyGrabRecord grabRecord : grabRecords) {
+ def conf = grabRecord.conf ?: ['*']
+ DefaultDependencyDescriptor dd = md.dependencies.find {it.dependencyRevisionId.equals(grabRecord.mrid)}
+ if (dd) {
+ createAndAddDependencyArtifactDescriptor(dd, grabRecord, conf)
+ } else {
+ dd = new DefaultDependencyDescriptor(md, grabRecord.mrid, grabRecord.force,
+ grabRecord.changing, grabRecord.transitive)
+ conf.each {dd.addDependencyConfiguration('default', it)}
+ createAndAddDependencyArtifactDescriptor(dd, grabRecord, conf)
+ md.addDependency(dd)
+ }
+ }
+
+ // resolve grab and dependencies
+ ResolveOptions resolveOptions = new ResolveOptions()\
+ .setConfs(['default'] as String[])\
+ .setOutputReport(false)\
+ .setValidate(args.containsKey('validate') ? args.validate : false)
+
+ ivyInstance.settings.defaultResolver = args.autoDownload ? 'downloadGrapes' : 'cachedGrapes'
+ if (args.disableChecksums) {
+ ivyInstance.settings.setVariable('ivy.checksums', '')
+ }
+ boolean reportDownloads = System.getProperty('groovy.grape.report.downloads', 'false') == 'true'
+ if (reportDownloads) {
+ ivyInstance.eventManager.addIvyListener([progress:{ ivyEvent -> switch(ivyEvent) {
+ case StartResolveEvent:
+ ivyEvent.moduleDescriptor.dependencies.each { it ->
+ def name = it.toString()
+ if (!resolvedDependencies.contains(name)) {
+ resolvedDependencies << name
+ System.err.println "Resolving " + name
+ }
+ }
+ break
+ case PrepareDownloadEvent:
+ ivyEvent.artifacts.each { it ->
+ def name = it.toString()
+ if (!downloadedArtifacts.contains(name)) {
+ downloadedArtifacts << name
+ System.err.println "Preparing to download artifact " + name
+ }
+ }
+ break
+ } } ] as IvyListener)
+ }
+
+ ResolveReport report = null
+ int attempt = 8 // max of 8 times
+ while (true) {
+ try {
+ report = ivyInstance.resolve(md, resolveOptions)
+ break
+ } catch(IOException ioe) {
+ if (attempt--) {
+ if (reportDownloads)
+ System.err.println "Grab Error: retrying..."
+ sleep attempt > 4 ? 350 : 1000
+ continue
+ }
+ throw new RuntimeException("Error grabbing grapes -- $ioe.message")
+ }
+ }
+
+ if (report.hasError()) {
+ throw new RuntimeException("Error grabbing Grapes -- $report.allProblemMessages")
+ }
+ if (report.downloadSize && reportDownloads) {
+ System.err.println "Downloaded ${report.downloadSize >> 10} Kbytes in ${report.downloadTime}ms:\n ${report.allArtifactsReports*.toString().join('\n ')}"
+ }
+ md = report.moduleDescriptor
+
+ if (!args.preserveFiles) {
+ cacheManager.getResolvedIvyFileInCache(md.moduleRevisionId).delete()
+ cacheManager.getResolvedIvyPropertiesInCache(md.moduleRevisionId).delete()
+ }
+
+ return report
+ }
+
+ private void createAndAddDependencyArtifactDescriptor(DefaultDependencyDescriptor dd, IvyGrabRecord grabRecord, List conf) {
+ // TODO: find out "unknown" reason and change comment below - also, confirm conf[0] check vs conf.contains('optional')
+ if (conf[0]!="optional" || grabRecord.classifier) { // for some unknown reason optional dependencies should not have an artifactDescriptor
+ def dad = new DefaultDependencyArtifactDescriptor(dd,
+ grabRecord.mrid.name, grabRecord.type ?: 'jar', grabRecord.ext ?: 'jar', null, grabRecord.classifier ? [classifier: grabRecord.classifier] : null)
+ conf.each { dad.addConfiguration(it) }
+ dd.addDependencyArtifact('default', dad)
+ }
+ }
+
+ public void uninstallArtifact(String group, String module, String rev) {
+ // TODO consider transitive uninstall as an option
+ Pattern ivyFilePattern = ~/ivy-(.*)\.xml/ //TODO get pattern from ivy conf
+ grapeCacheDir.eachDir { File groupDir ->
+ if (groupDir.name == group) groupDir.eachDir { File moduleDir ->
+ if (moduleDir.name == module) moduleDir.eachFileMatch(ivyFilePattern) { File ivyFile ->
+ def m = ivyFilePattern.matcher(ivyFile.name)
+ if (m.matches() && m.group(1) == rev) {
+ // TODO handle other types? e.g. 'dlls'
+ def jardir = new File(moduleDir, 'jars')
+ if (!jardir.exists()) return
+ def dbf = DocumentBuilderFactory.newInstance()
+ def db = dbf.newDocumentBuilder()
+ def root = db.parse(ivyFile).documentElement
+ def publis = root.getElementsByTagName('publications')
+ for (int i=0; i
+ def excludeRule = new DefaultExcludeRule(new ArtifactId(
+ new ModuleId(map.group, map.module), PatternMatcher.ANY_EXPRESSION,
+ PatternMatcher.ANY_EXPRESSION,
+ PatternMatcher.ANY_EXPRESSION),
+ ExactPatternMatcher.INSTANCE, null)
+ excludeRule.addConfiguration('default')
+ md.addExcludeRule(excludeRule)
+ }
+ }
+
+ public Map>> enumerateGrapes() {
+ Map>> bunches = [:]
+ Pattern ivyFilePattern = ~/ivy-(.*)\.xml/ //TODO get pattern from ivy conf
+ grapeCacheDir.eachDir {File groupDir ->
+ Map> grapes = [:]
+ bunches[groupDir.name] = grapes
+ groupDir.eachDir { File moduleDir ->
+ def versions = []
+ moduleDir.eachFileMatch(ivyFilePattern) {File ivyFile ->
+ def m = ivyFilePattern.matcher(ivyFile.name)
+ if (m.matches()) versions += m.group(1)
+ }
+ grapes[moduleDir.name] = versions
+ }
+ }
+ return bunches
+ }
+
+ public URI[] resolve(Map args, Map ... dependencies) {
+ resolve(args, null, dependencies)
+ }
+
+ public URI[] resolve(Map args, List depsInfo, Map ... dependencies) {
+ // identify the target classloader early, so we fail before checking repositories
+ def loader = chooseClassLoader(
+ classLoader: args.remove('classLoader'),
+ refObject: args.remove('refObject'),
+ calleeDepth: args.calleeDepth ?: DEFAULT_DEPTH,
+ )
+
+ // check for non-fail null.
+ // If we were in fail mode we would have already thrown an exception
+ if (!loader) return
+
+ resolve(loader, args, depsInfo, dependencies)
+ }
+
+ URI [] resolve(ClassLoader loader, Map args, Map... dependencies) {
+ return resolve(loader, args, null, dependencies)
+ }
+
+ URI [] resolve(ClassLoader loader, Map args, List depsInfo, Map... dependencies) {
+ // check for mutually exclusive arguments
+ Set keys = args.keySet()
+ keys.each {a ->
+ Set badArgs = exclusiveGrabArgs[a]
+ if (badArgs && !badArgs.disjoint(keys)) {
+ throw new RuntimeException("Mutually exclusive arguments passed into grab: ${keys.intersect(badArgs) + a}")
+ }
+ }
+
+ // check the kill switch
+ if (!enableGrapes) { return }
+
+ boolean populateDepsInfo = (depsInfo != null)
+
+ Set localDeps = getLoadedDepsForLoader(loader)
+
+ dependencies.each {
+ IvyGrabRecord igr = createGrabRecord(it)
+ grabRecordsForCurrDependencies.add(igr)
+ localDeps.add(igr)
+ }
+ // the call to reverse ensures that the newest additions are in
+ // front causing existing dependencies to come last and thus
+ // claiming higher priority. Thus when module versions clash we
+ // err on the side of using the class already loaded into the
+ // classloader rather than adding another jar of the same module
+ // with a different version
+ ResolveReport report = null
+ try {
+ report = getDependencies(args, *localDeps.asList().reverse())
+ } catch (Exception e) {
+ // clean-up the state first
+ localDeps.removeAll(grabRecordsForCurrDependencies)
+ grabRecordsForCurrDependencies.clear()
+ throw e
+ }
+
+ List results = []
+ for (ArtifactDownloadReport adl in report.allArtifactsReports) {
+ //TODO check artifact type, jar vs library, etc
+ if (adl.localFile) {
+ results += adl.localFile.toURI()
+ }
+ }
+
+ if (populateDepsInfo) {
+ def deps = report.dependencies
+ deps.each { depNode ->
+ def id = depNode.id
+ depsInfo << ['group' : id.organisation, 'module' : id.name, 'revision' : id.revision]
+ }
+ }
+
+ return results as URI[]
+ }
+
+ private Set getLoadedDepsForLoader(ClassLoader loader) {
+ Set localDeps = loadedDeps.get(loader)
+ if (localDeps == null) {
+ // use a linked set to preserve initial insertion order
+ localDeps = new LinkedHashSet()
+ loadedDeps.put(loader, localDeps)
+ }
+ return localDeps
+ }
+
+ public Map[] listDependencies (ClassLoader classLoader) {
+ if (loadedDeps.containsKey(classLoader)) {
+ List