Introduced a plugin-API and show usage with rhino-xml

rhino-xml/src/main/java/module-info.java

@@ -3,4 +3,7 @@
 
     requires transitive org.mozilla.rhino;
     requires transitive java.xml;
+
+    provides org.mozilla.javascript.Plugin with
+            org.mozilla.javascript.xmlimpl.XmlPlugin;
 }

rhino-xml/src/main/java/org/mozilla/javascript/xmlimpl/XmlPlugin.java

@@ -0,0 +1,38 @@
+package org.mozilla.javascript.xmlimpl;
+
+import org.mozilla.javascript.CompilerEnvirons;
+import org.mozilla.javascript.Context;
+import org.mozilla.javascript.LazilyLoadedCtor;
+import org.mozilla.javascript.Plugin;
+import org.mozilla.javascript.ScriptableObject;
+
+/**
+ * Registers the XML objects in the scope.
+ *
+ * @author Roland Praml, Foconis Analytics GmbH
+ */
+public class XmlPlugin implements Plugin {
+
+    @Override
+    public String getName() {
+        return "xml";
+    }
+
+    @Override
+    public void initSafeStandardObjects(Context cx, ScriptableObject scope, boolean sealed) {
+        if (cx.hasFeature(Context.FEATURE_E4X)) {
+            String xmlImpl = XMLLibImpl.class.getName();
+            new LazilyLoadedCtor(scope, "XML", xmlImpl, sealed, true);
+            new LazilyLoadedCtor(scope, "XMLList", xmlImpl, sealed, true);
+            new LazilyLoadedCtor(scope, "Namespace", xmlImpl, sealed, true);
+            new LazilyLoadedCtor(scope, "QName", xmlImpl, sealed, true);
+        }
+    }
+
+    @Override
+    public void initCompilerEnvirons(Context cx, CompilerEnvirons compilerEnvirons) {
+        if (cx.hasFeature(Context.FEATURE_E4X)) {
+            compilerEnvirons.setXmlAvailable(true);
+        }
+    }
+}

rhino-xml/src/main/resources/META-INF/services/org.mozilla.javascript.Plugin

@@ -0,0 +1 @@
+org.mozilla.javascript.xmlimpl.XmlPlugin

rhino-xml/src/test/java/org/mozilla/javascript/tests/XMLPresentTest.java

@@ -0,0 +1,32 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+package org.mozilla.javascript.tests;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import org.junit.Test;
+import org.mozilla.javascript.Context;
+import org.mozilla.javascript.ContextFactory;
+import org.mozilla.javascript.Scriptable;
+
+/**
+ * Test if XML is present. This test exists in "rhino-xml" where XML is present and in "rhino",
+ * where XML is not on classpath.
+ *
+ * @author Roland Praml
+ */
+public class XMLPresentTest {
+
+    @Test
+    public void testXMLPresent() {
+        try (Context cx = ContextFactory.getGlobal().enterContext()) {
+            Scriptable scope = cx.initStandardObjects();
+            Object result =
+                    cx.evaluateString(
+                            scope, "new XML('<a></a>').toXMLString();", "source", 1, null);
+            assertEquals("<a/>", Context.toString(result));
+        }
+    }
+}

rhino/src/main/java/module-info.java

@@ -14,4 +14,6 @@
     requires java.compiler;
     requires jdk.dynalink;
     requires transitive java.desktop;
+
+    uses org.mozilla.javascript.Plugin;
 }

rhino/src/main/java/org/mozilla/javascript/CompilerEnvirons.java

@@ -33,7 +33,6 @@ public void initFromContext(Context cx) {
         allowMemberExprAsFunctionName = cx.hasFeature(Context.FEATURE_MEMBER_EXPR_AS_FUNCTION_NAME);
         strictMode = cx.hasFeature(Context.FEATURE_STRICT_MODE);
         warningAsError = cx.hasFeature(Context.FEATURE_WARNING_AS_ERROR);
-        xmlAvailable = cx.hasFeature(Context.FEATURE_E4X);
 
         optimizationLevel = cx.getOptimizationLevel();
 
@@ -42,6 +41,7 @@ public void initFromContext(Context cx) {
 
         // Observer code generation in compiled code :
         generateObserverCount = cx.isGenerateObserverCount();
+        cx.getFactory().getPlugins().forEach(plugin -> plugin.initCompilerEnvirons(cx, this));
     }
 
     public final ErrorReporter getErrorReporter() {

rhino/src/main/java/org/mozilla/javascript/Context.java

@@ -174,8 +174,9 @@ public class Context implements Closeable {
      * {@link #VERSION_DEFAULT} or is at least {@link #VERSION_1_6}.
      *
      * @since 1.6 Release 1
+     * @deprecated This flag may be removed later.
      */
-    public static final int FEATURE_E4X = 6;
+    @Deprecated public static final int FEATURE_E4X = 6;
 
     /**
      * Control if dynamic scope should be used for name access. If hasFeature(FEATURE_DYNAMIC_SCOPE)
@@ -2226,20 +2227,6 @@ public boolean hasFeature(int featureIndex) {
         return f.hasFeature(this, featureIndex);
     }
 
-    /**
-     * Returns an object which specifies an E4X implementation to use within this <code>Context
-     * </code>. Note that the XMLLib.Factory interface should be considered experimental.
-     *
-     * <p>The default implementation uses the implementation provided by this <code>Context</code>'s
-     * {@link ContextFactory}.
-     *
-     * @return An XMLLib.Factory. Should not return <code>null</code> if {@link #FEATURE_E4X} is
-     *     enabled. See {@link #hasFeature}.
-     */
-    public XMLLib.Factory getE4xImplementationFactory() {
-        return getFactory().getE4xImplementationFactory();
-    }
-
     /**
      * Get threshold of executed instructions counter that triggers call to <code>
      * observeInstructionCount()</code>. When the threshold is zero, instruction counting is

rhino/src/main/java/org/mozilla/javascript/ContextFactory.java

@@ -10,6 +10,10 @@
 
 import java.security.AccessController;
 import java.security.PrivilegedAction;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.ServiceLoader;
 
 /**
  * Factory class that Rhino runtime uses to create new {@link Context} instances. A <code>
@@ -114,6 +118,25 @@ public class ContextFactory {
     private volatile Object listeners;
     private boolean disabledListening;
     private ClassLoader applicationClassLoader;
+    private final List<Plugin> plugins;
+
+    /** returns a list of plugins found by the ServiceLoader */
+    public static List<Plugin> getDefaultPluginsFromServiceLoader() {
+        List<Plugin> result = new ArrayList<Plugin>();
+        ServiceLoader.load(Plugin.class)
+                .forEach(
+                        plugin -> {
+                            String disabled =
+                                    SecurityUtilities.getSystemProperty(
+                                            "rhino.plugin." + plugin.getName() + ".disabled");
+                            if ("1".equals(disabled) || "true".equals(disabled)) {
+                                // the plugin is disabled
+                            } else {
+                                result.add(plugin);
+                            }
+                        });
+        return result;
+    }
 
     /** Listener of {@link Context} creation and release events. */
     public interface Listener {
@@ -127,6 +150,16 @@ public interface Listener {
         public void contextReleased(Context cx);
     }
 
+    /** Constructs a new ContextFactory with the plugins found by serviceLoader. */
+    public ContextFactory() {
+        this(getDefaultPluginsFromServiceLoader());
+    }
+
+    /** Constructs a new ContextFactory with a given list of plugins. */
+    public ContextFactory(List<Plugin> plugins) {
+        this.plugins = Collections.unmodifiableList(plugins);
+    }
+
     /**
      * Get global ContextFactory.
      *
@@ -295,42 +328,6 @@ protected boolean hasFeature(Context cx, int featureIndex) {
         throw new IllegalArgumentException(String.valueOf(featureIndex));
     }
 
-    private static boolean isDom3Present() {
-        Class<?> nodeClass = Kit.classOrNull("org.w3c.dom.Node");
-        if (nodeClass == null) return false;
-        // Check to see whether DOM3 is present; use a new method defined in
-        // DOM3 that is vital to our implementation
-        try {
-            nodeClass.getMethod("getUserData", String.class);
-            return true;
-        } catch (NoSuchMethodException e) {
-            return false;
-        }
-    }
-
-    /**
-     * Provides a default {@link org.mozilla.javascript.xml.XMLLib.Factory XMLLib.Factory} to be
-     * used by the <code>Context</code> instances produced by this factory. See {@link
-     * Context#getE4xImplementationFactory} for details.
-     *
-     * <p>May return null, in which case E4X functionality is not supported in Rhino.
-     *
-     * <p>The default implementation now prefers the DOM3 E4X implementation.
-     */
-    protected org.mozilla.javascript.xml.XMLLib.Factory getE4xImplementationFactory() {
-        // Must provide default implementation, rather than abstract method,
-        // so that past implementors of ContextFactory do not fail at runtime
-        // upon invocation of this method.
-        // Note that the default implementation returns null if we
-        // neither have XMLBeans nor a DOM3 implementation present.
-
-        if (isDom3Present()) {
-            return org.mozilla.javascript.xml.XMLLib.Factory.create(
-                    "org.mozilla.javascript.xmlimpl.XMLLibImpl");
-        }
-        return null;
-    }
-
     /**
      * Create class loader for generated classes. This method creates an instance of the default
      * implementation of {@link GeneratedClassLoader}. Rhino uses this interface to load generated
@@ -552,4 +549,9 @@ public final void exit() {
     public final Context enterContext(Context cx) {
         return Context.enter(cx, this);
     }
+
+    /** Returns a list of plugins. */
+    public List<Plugin> getPlugins() {
+        return plugins;
+    }
 }

rhino/src/main/java/org/mozilla/javascript/LazilyLoadedCtor.java

@@ -35,7 +35,7 @@ public LazilyLoadedCtor(
         this(scope, propertyName, className, sealed, false);
     }
 
-    LazilyLoadedCtor(
+    public LazilyLoadedCtor(
             ScriptableObject scope,
             String propertyName,
             String className,

rhino/src/main/java/org/mozilla/javascript/Plugin.java

@@ -0,0 +1,21 @@
+package org.mozilla.javascript;
+
+/**
+ * Plugins may be loaded with the serviceLocator.
+ *
+ * @author Roland Praml, Foconis Analytics GmbH
+ */
+public interface Plugin {
+
+    /** The name of the plugin. */
+    String getName();
+
+    /** Initializes the safe standard objects. */
+    default void initSafeStandardObjects(Context cx, ScriptableObject scope, boolean sealed) {}
+
+    /** Initializes the (unsafe) standard objects. */
+    default void initStandardObjects(Context cx, ScriptableObject scope, boolean sealed) {}
+
+    /** Initialize the compiler environmnt. */
+    default void initCompilerEnvirons(Context cx, CompilerEnvirons compilerEnvirons) {}
+}

rhino/src/main/java/org/mozilla/javascript/ScriptRuntime.java

@@ -192,21 +192,14 @@ public static ScriptableObject initSafeStandardObjects(
         NativeJavaObject.init(scope, sealed);
         NativeJavaMap.init(scope, sealed);
 
-        boolean withXml =
-                cx.hasFeature(Context.FEATURE_E4X) && cx.getE4xImplementationFactory() != null;
-
         // define lazy-loaded properties using their class name
         new LazilyLoadedCtor(
                 scope, "RegExp", "org.mozilla.javascript.regexp.NativeRegExp", sealed, true);
         new LazilyLoadedCtor(
                 scope, "Continuation", "org.mozilla.javascript.NativeContinuation", sealed, true);
 
-        if (withXml) {
-            String xmlImpl = cx.getE4xImplementationFactory().getImplementationClassName();
-            new LazilyLoadedCtor(scope, "XML", xmlImpl, sealed, true);
-            new LazilyLoadedCtor(scope, "XMLList", xmlImpl, sealed, true);
-            new LazilyLoadedCtor(scope, "Namespace", xmlImpl, sealed, true);
-            new LazilyLoadedCtor(scope, "QName", xmlImpl, sealed, true);
+        for (Plugin plugin : cx.getFactory().getPlugins()) {
+            plugin.initSafeStandardObjects(cx, scope, sealed);
         }
 
         if (((cx.getLanguageVersion() >= Context.VERSION_1_8)
@@ -303,6 +296,9 @@ public static ScriptableObject initStandardObjects(
             Context cx, ScriptableObject scope, boolean sealed) {
         ScriptableObject s = initSafeStandardObjects(cx, scope, sealed);
 
+        for (Plugin plugin : cx.getFactory().getPlugins()) {
+            plugin.initStandardObjects(cx, s, sealed);
+        }
         new LazilyLoadedCtor(
                 s, "Packages", "org.mozilla.javascript.NativeJavaTopPackage", sealed, true);
         new LazilyLoadedCtor(

rhino/src/main/java/org/mozilla/javascript/xml/XMLLib.java

@@ -15,28 +15,6 @@
 public abstract class XMLLib {
     private static final Object XML_LIB_KEY = new Object();
 
-    /**
-     * An object which specifies an XMLLib implementation to be used at runtime.
-     *
-     * <p>This interface should be considered experimental. It may be better (and certainly more
-     * flexible) to write an interface that returns an XMLLib object rather than a class name, for
-     * example. But that would cause many more ripple effects in the code, all the way back to
-     * {@link ScriptRuntime}.
-     */
-    public abstract static class Factory {
-
-        public static Factory create(final String className) {
-            return new Factory() {
-                @Override
-                public String getImplementationClassName() {
-                    return className;
-                }
-            };
-        }
-
-        public abstract String getImplementationClassName();
-    }
-
     public static XMLLib extractFromScopeOrNull(Scriptable scope) {
         ScriptableObject so = ScriptRuntime.getLibraryScopeOrNull(scope);
         if (so == null) {

rhino/src/test/java/org/mozilla/javascript/tests/XMLPresentTest.java

@@ -0,0 +1,36 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+package org.mozilla.javascript.tests;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.fail;
+
+import org.junit.Test;
+import org.mozilla.javascript.Context;
+import org.mozilla.javascript.ContextFactory;
+import org.mozilla.javascript.EcmaError;
+import org.mozilla.javascript.Scriptable;
+
+/**
+ * Test if XML is present. This test exists in "rhino-xml" where XML is present and in "rhino",
+ * where XML is not on classpath.
+ *
+ * @author Roland Praml
+ */
+public class XMLPresentTest {
+
+    @Test
+    public void testXMLPresent() {
+        try (Context cx = ContextFactory.getGlobal().enterContext()) {
+            Scriptable scope = cx.initStandardObjects();
+            Object result =
+                    cx.evaluateString(
+                            scope, "new XML('<a></a>').toXMLString();", "source", 1, null);
+            fail("not expected");
+        } catch (EcmaError e) {
+            assertEquals("ReferenceError: \"XML\" is not defined. (source#1)", e.getMessage());
+        }
+    }
+}