git.basschouten.com Git - openhab-addons.git/blob

   1 /**
   2  * Copyright (c) 2010-2023 Contributors to the openHAB project
   3  *
   4  * See the NOTICE file(s) distributed with this work for additional
   5  * information.
   6  *
   7  * This program and the accompanying materials are made available under the
   8  * terms of the Eclipse Public License 2.0 which is available at
   9  * http://www.eclipse.org/legal/epl-2.0
  10  *
  11  * SPDX-License-Identifier: EPL-2.0
  12  */
  13 package org.openhab.automation.jrubyscripting.internal;
  14
  15 import java.io.File;
  16 import java.util.HashMap;
  17 import java.util.List;
  18 import java.util.Map;
  19 import java.util.Objects;
  20 import java.util.stream.Collectors;
  21 import java.util.stream.Stream;
  22
  23 import javax.script.ScriptContext;
  24 import javax.script.ScriptEngine;
  25 import javax.script.ScriptException;
  26
  27 import org.eclipse.jdt.annotation.NonNullByDefault;
  28 import org.eclipse.jdt.annotation.Nullable;
  29 import org.openhab.automation.jrubyscripting.internal.watch.JRubyDependencyTracker;
  30 import org.openhab.core.automation.module.script.AbstractScriptEngineFactory;
  31 import org.openhab.core.automation.module.script.ScriptDependencyTracker;
  32 import org.openhab.core.automation.module.script.ScriptEngineFactory;
  33 import org.openhab.core.automation.module.script.ScriptExtensionManagerWrapper;
  34 import org.openhab.core.config.core.ConfigurableService;
  35 import org.osgi.framework.Constants;
  36 import org.osgi.service.component.annotations.Activate;
  37 import org.osgi.service.component.annotations.Component;
  38 import org.osgi.service.component.annotations.Deactivate;
  39 import org.osgi.service.component.annotations.Modified;
  40 import org.osgi.service.component.annotations.Reference;
  41 import org.osgi.service.component.annotations.ReferenceCardinality;
  42 import org.osgi.service.component.annotations.ReferencePolicy;
  43
  44 /**
  45  * This is an implementation of a {@link ScriptEngineFactory} for Ruby.
  46  *
  47  * @author Brian O'Connell - Initial contribution
  48  * @author Jimmy Tanagra - Add require injection
  49  */
  50 @NonNullByDefault
  51 @Component(service = ScriptEngineFactory.class, configurationPid = "org.openhab.automation.jrubyscripting", property = Constants.SERVICE_PID
  52         + "=org.openhab.automation.jrubyscripting")
  53 @ConfigurableService(category = "automation", label = "JRuby Scripting", description_uri = "automation:jruby")
  54 public class JRubyScriptEngineFactory extends AbstractScriptEngineFactory {
  55     private final JRubyScriptEngineConfiguration configuration = new JRubyScriptEngineConfiguration();
  56
  57     private final javax.script.ScriptEngineFactory factory = new org.jruby.embed.jsr223.JRubyEngineFactory();
  58
  59     private final List<String> scriptTypes = Stream.concat(Objects.requireNonNull(factory.getExtensions()).stream(),
  60             Objects.requireNonNull(factory.getMimeTypes()).stream()).collect(Collectors.toUnmodifiableList());
  61
  62     private JRubyDependencyTracker jrubyDependencyTracker;
  63
  64     // Adds $ in front of a set of variables so that Ruby recognizes them as global
  65     // variables
  66     private static Map.Entry<String, Object> mapGlobalPresets(Map.Entry<String, Object> entry) {
  67         if (Character.isLowerCase(entry.getKey().charAt(0)) && !(entry.getValue() instanceof Class)
  68                 && !(entry.getValue() instanceof Enum)) {
  69             return Map.entry("$" + entry.getKey(), entry.getValue());
  70         } else {
  71             return entry;
  72         }
  73     }
  74
  75     @Activate
  76     public JRubyScriptEngineFactory(Map<String, Object> config) {
  77         jrubyDependencyTracker = new JRubyDependencyTracker(this);
  78         modified(config);
  79     }
  80
  81     @Deactivate
  82     protected void deactivate() {
  83         jrubyDependencyTracker.deactivate();
  84     }
  85
  86     // The modified call updates configuration for the automation
  87     @Modified
  88     protected void modified(Map<String, Object> config) {
  89         configuration.update(config, factory);
  90         // Re-initialize the dependency tracker's watchers.
  91         jrubyDependencyTracker.deactivate();
  92         jrubyDependencyTracker.activate();
  93     }
  94
  95     @Override
  96     public List<String> getScriptTypes() {
  97         return scriptTypes;
  98     }
  99
 100     @Override
 101     public void scopeValues(ScriptEngine scriptEngine, Map<String, Object> scopeValues) {
 102         // Empty comments prevent the formatter from breaking up the correct streams
 103         // chaining
 104         logger.debug("Scope Values: {}", scopeValues);
 105         Map<String, Object> filteredScopeValues = //
 106                 scopeValues //
 107                         .entrySet() //
 108                         .stream() //
 109                         .map(JRubyScriptEngineFactory::mapGlobalPresets) //
 110                         .collect(Collectors.toMap(map -> map.getKey(), map -> map.getValue())); //
 111
 112         Map<Boolean, Map<String, Object>> partitionedMap = //
 113                 filteredScopeValues.entrySet() //
 114                         .stream() //
 115                         .collect(Collectors.partitioningBy(entry -> (entry.getValue() instanceof Class),
 116                                 Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue)));
 117
 118         super.scopeValues(scriptEngine, partitionedMap.getOrDefault(false, new HashMap<>()));
 119         importClassesToRuby(scriptEngine, partitionedMap.getOrDefault(true, new HashMap<>()));
 120
 121         Object scriptExtension = scopeValues.get("scriptExtension");
 122         if (scriptExtension instanceof ScriptExtensionManagerWrapper) {
 123             ScriptExtensionManagerWrapper wrapper = (ScriptExtensionManagerWrapper) scriptExtension;
 124             // we inject like this instead of using the script context, because
 125             // this is executed _before_ the dependency tracker is added to the script
 126             // context.
 127             // But we need this set up before we inject our requires
 128             scriptEngine.put("$dependencyListener", jrubyDependencyTracker.getTracker(wrapper.getScriptIdentifier()));
 129         }
 130
 131         // scopeValues is called twice. The first call only passed 'se'. The second call
 132         // passed the rest of the
 133         // presets, including 'ir'. We wait for the second call before running the
 134         // require statements.
 135         if (scopeValues.containsKey("ir")) {
 136             configuration.injectRequire(scriptEngine);
 137         }
 138     }
 139
 140     private void importClassesToRuby(ScriptEngine scriptEngine, Map<String, Object> objects) {
 141         try {
 142             scriptEngine.put("__classes", objects);
 143             final String code = "__classes.each { |(name, klass)| Object.const_set(name, klass.ruby_class) unless Object.const_defined?(name, false) }";
 144             scriptEngine.eval(code);
 145             // clean up our temporary variable
 146             scriptEngine.getBindings(ScriptContext.ENGINE_SCOPE).remove("__classes");
 147         } catch (ScriptException e) {
 148             logger.debug("Error importing java classes", e);
 149         }
 150     }
 151
 152     @Override
 153     public @Nullable ScriptEngine createScriptEngine(String scriptType) {
 154         if (!scriptTypes.contains(scriptType)) {
 155             return null;
 156         }
 157         ScriptEngine engine = factory.getScriptEngine();
 158         configuration.configureRubyEnvironment(engine);
 159         return engine;
 160     }
 161
 162     @Override
 163     public @Nullable ScriptDependencyTracker getDependencyTracker() {
 164         return jrubyDependencyTracker;
 165     }
 166
 167     @Reference(cardinality = ReferenceCardinality.MULTIPLE, policy = ReferencePolicy.DYNAMIC, unbind = "removeChangeTracker")
 168     public void addChangeTracker(ScriptDependencyTracker.Listener listener) {
 169         jrubyDependencyTracker.addChangeTracker(listener);
 170     }
 171
 172     public void removeChangeTracker(ScriptDependencyTracker.Listener listener) {
 173         jrubyDependencyTracker.removeChangeTracker(listener);
 174     }
 175
 176     public List<String> getRubyLibPaths() {
 177         return configuration.getRubyLibPaths();
 178     }
 179
 180     public boolean isFileInLoadPath(String file) {
 181         for (String path : getRubyLibPaths()) {
 182             if (file.startsWith(new File(path).toString() + File.separator)) {
 183                 return true;
 184             }
 185         }
 186         return false;
 187     }
 188
 189     public String getGemHome() {
 190         return configuration.getSpecificGemHome();
 191     }
 192
 193     public boolean isFileInGemHome(String file) {
 194         String gemHome = configuration.getGemHomeBase();
 195         if (gemHome.isEmpty()) {
 196             return false;
 197         }
 198         return file.startsWith(gemHome + File.separator);
 199     }
 200 }