/*
* 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 org.apache.sling.scripting.javascript.helper;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.Reader;
import java.io.Serializable;
import org.apache.sling.api.resource.Resource;
import org.apache.sling.api.resource.ResourceResolver;
import org.apache.sling.api.resource.ResourceUtil;
import org.apache.sling.api.scripting.SlingBindings;
import org.apache.sling.api.scripting.SlingScriptHelper;
import org.apache.sling.scripting.javascript.RhinoJavaScriptEngineFactory;
import org.apache.sling.scripting.javascript.io.EspReader;
import org.mozilla.javascript.Context;
import org.mozilla.javascript.IdFunctionCall;
import org.mozilla.javascript.IdFunctionObject;
import org.mozilla.javascript.Kit;
import org.mozilla.javascript.ScriptRuntime;
import org.mozilla.javascript.Scriptable;
import org.mozilla.javascript.ScriptableObject;
import org.mozilla.javascript.Wrapper;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* The <code>SlingGlobal</code> class provides two interesting new global
* functions which are not part of the ECMAScript standard but which are
* available in the Rhino Shell and which may be of use by JavaScripts:
* <p>
* <dl>
* <dt><code>print(args, ...)</code></dt>
* <dd>Prints the arguments <code>args</code> in a single message to the
* scripts logger available as the global <em>log</em> variable.</dd>
* <dt><code>load(args, ...)</code></dt>
* <dd>Loads the scripts named as parameters into the current scope one, after
* the other. Usually the script files are read as plain JavaScript files. If
* the file extension happens to be <em>.esp</em> to indicate an ECMAScript
* Server Page, the file is read through an
* {@link org.apache.sling.scripting.javascript.io.EspReader}. Failure to read
* one of the files throws an error.</dd>
* </dl>
*/
public class SlingGlobal implements Serializable, IdFunctionCall {
static final long serialVersionUID = 6080442165748707530L;
private static final Object FTAG = new Object();
private static final int Id_load = 1;
private static final int Id_print = 2;
private static final int LAST_SCOPE_FUNCTION_ID = 2;
/** default log */
private final Logger defaultLog = LoggerFactory.getLogger(getClass());
public static void init(Scriptable scope, boolean sealed) {
SlingGlobal obj = new SlingGlobal();
for (int id = 1; id <= LAST_SCOPE_FUNCTION_ID; ++id) {
String name;
int arity = 1;
switch (id) {
case Id_load:
name = "load";
break;
case Id_print:
name = "print";
break;
default:
throw Kit.codeBug();
}
IdFunctionObject f = new IdFunctionObject(obj, FTAG, id, name,
arity, scope);
if (sealed) {
f.sealObject();
}
f.exportAsScopeProperty();
}
}
public Object execIdCall(IdFunctionObject f, Context cx, Scriptable scope,
Scriptable thisObj, Object[] args) {
if (f.hasTag(FTAG)) {
int methodId = f.methodId();
switch (methodId) {
case Id_load: {
load(cx, thisObj, args);
return Context.getUndefinedValue();
}
case Id_print: {
print(cx, thisObj, args);
return Context.getUndefinedValue();
}
}
}
throw f.unknown();
}
private void print(Context cx, Scriptable thisObj, Object[] args) {
StringBuffer message = new StringBuffer();
for (int i = 0; i < args.length; i++) {
if (i > 0) {
message.append(" ");
}
// Convert the arbitrary JavaScript value into a string form.
String s = ScriptRuntime.toString(args[i]);
message.append(s);
}
getLogger(cx, thisObj).info(message.toString());
}
private void load(Context cx, Scriptable thisObj, Object[] args) {
SlingScriptHelper sling = getProperty(cx, thisObj, SlingBindings.SLING,
SlingScriptHelper.class);
if (sling == null) {
throw new NullPointerException(SlingBindings.SLING);
}
Scriptable globalScope = ScriptableObject.getTopLevelScope(thisObj);
Resource scriptResource = sling.getScript().getScriptResource();
ResourceResolver resolver = scriptResource.getResourceResolver();
// the path of the current script to resolve realtive paths
String currentScript = sling.getScript().getScriptResource().getPath();
String scriptParent = ResourceUtil.getParent(currentScript);
for (Object arg : args) {
String scriptName = ScriptRuntime.toString(arg);
Resource loadScript = null;
if (!scriptName.startsWith("/")) {
String absScriptName = scriptParent + "/" + scriptName;
loadScript = resolver.resolve(absScriptName);
}
// not resolved relative to the current script
if (loadScript == null) {
loadScript = resolver.resolve(scriptName);
}
if (loadScript == null) {
throw Context.reportRuntimeError("Script file " + scriptName
+ " not found");
}
InputStream scriptStream = loadScript.adaptTo(InputStream.class);
if (scriptStream == null) {
throw Context.reportRuntimeError("Script file " + scriptName
+ " cannot be read from");
}
try {
// reader for the stream
Reader scriptReader = new InputStreamReader(scriptStream);
// check whether we have to wrap the basic reader
if (scriptName.endsWith(RhinoJavaScriptEngineFactory.ESP_SCRIPT_EXTENSION)) {
scriptReader = new EspReader(scriptReader);
}
// read the suff buffered for better performance
scriptReader = new BufferedReader(scriptReader);
// now, let's go
cx.evaluateReader(globalScope, scriptReader, scriptName, 1,
null);
} catch (IOException ioe) {
throw Context.reportRuntimeError("Failure reading file "
+ scriptName + ": " + ioe);
} finally {
// ensure the script input stream is closed
try {
scriptStream.close();
} catch (IOException ignore) {
}
}
}
}
/**
* Returns the script logger or the logger of this class as a fallback
* default if the global log variable is not accessible.
*/
private Logger getLogger(Context cx, Scriptable scope) {
Logger log = getProperty(cx, scope, SlingBindings.LOG, Logger.class);
if (log == null) {
log = this.defaultLog;
}
return log;
}
/**
* Returns the named toplevel property converted to the requested
* <code>type</code> or <code>null</code> if no such property exists or
* the property is of the wrong type.
*/
@SuppressWarnings("unchecked")
private <Type> Type getProperty(Context cx, Scriptable scope, String name,
Class<Type> type) {
Object prop = ScriptRuntime.name(cx, scope, name);
if (prop instanceof Wrapper) {
prop = ((Wrapper) prop).unwrap();
}
if (type.isInstance(prop)) {
return (Type) prop; // unchecked case
}
return null;
}
}