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

   1 /**
   2  * Copyright (c) 2010-2022 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.util.HashMap;
  16 import java.util.List;
  17 import java.util.Map;
  18 import java.util.Set;
  19 import java.util.stream.Collectors;
  20 import java.util.stream.Stream;
  21
  22 import javax.script.ScriptEngine;
  23 import javax.script.ScriptException;
  24
  25 import org.eclipse.jdt.annotation.NonNullByDefault;
  26 import org.eclipse.jdt.annotation.Nullable;
  27 import org.openhab.core.automation.module.script.AbstractScriptEngineFactory;
  28 import org.openhab.core.automation.module.script.ScriptEngineFactory;
  29 import org.openhab.core.config.core.ConfigurableService;
  30 import org.osgi.service.component.annotations.Activate;
  31 import org.osgi.service.component.annotations.Component;
  32 import org.osgi.service.component.annotations.Modified;
  33
  34 /**
  35  * This is an implementation of a {@link ScriptEngineFactory} for Ruby.
  36  *
  37  * @author Brian O'Connell - Initial contribution
  38  */
  39 @NonNullByDefault
  40 @Component(service = ScriptEngineFactory.class, configurationPid = "org.openhab.automation.jrubyscripting")
  41 @ConfigurableService(category = "automation", label = "JRuby Scripting", description_uri = "automation:jruby")
  42 public class JRubyScriptEngineFactory extends AbstractScriptEngineFactory {
  43
  44     private final JRubyScriptEngineConfiguration configuration = new JRubyScriptEngineConfiguration();
  45
  46     // Filter out the File entry to prevent shadowing the Ruby File class which breaks Ruby in spectacularly
  47     // difficult ways to debug.
  48     private static final Set<String> FILTERED_PRESETS = Set.of("File");
  49     private static final Set<String> INSTANCE_PRESETS = Set.of();
  50     private static final Set<String> GLOBAL_PRESETS = Set.of("scriptExtension", "automationManager", "ruleRegistry",
  51             "items", "voice", "rules", "things", "events", "itemRegistry", "ir", "actions", "se", "audio",
  52             "lifecycleTracker");
  53
  54     private final javax.script.ScriptEngineFactory factory = new org.jruby.embed.jsr223.JRubyEngineFactory();
  55
  56     private final List<String> scriptTypes = Stream
  57             .concat(factory.getExtensions().stream(), factory.getMimeTypes().stream())
  58             .collect(Collectors.toUnmodifiableList());
  59
  60     // Adds @ in front of a set of variables so that Ruby recognizes them as instance variables
  61     private static Map.Entry<String, Object> mapInstancePresets(Map.Entry<String, Object> entry) {
  62         if (INSTANCE_PRESETS.contains(entry.getKey())) {
  63             return Map.entry("@" + entry.getKey(), entry.getValue());
  64         } else {
  65             return entry;
  66         }
  67     }
  68
  69     // Adds $ in front of a set of variables so that Ruby recognizes them as global variables
  70     private static Map.Entry<String, Object> mapGlobalPresets(Map.Entry<String, Object> entry) {
  71         if (GLOBAL_PRESETS.contains(entry.getKey())) {
  72             return Map.entry("$" + entry.getKey(), entry.getValue());
  73         } else {
  74             return entry;
  75         }
  76     }
  77
  78     // The activate call activates the automation and sets its configuration
  79     @Activate
  80     protected void activate(Map<String, Object> config) {
  81         configuration.update(config, factory);
  82     }
  83
  84     // The modified call updates configuration for the automation
  85     @Modified
  86     protected void modified(Map<String, Object> config) {
  87         configuration.update(config, factory);
  88     }
  89
  90     @Override
  91     public List<String> getScriptTypes() {
  92         return scriptTypes;
  93     }
  94
  95     @Override
  96     public void scopeValues(ScriptEngine scriptEngine, Map<String, Object> scopeValues) {
  97         // Empty comments prevent the formatter from breaking up the correct streams chaining
  98         logger.debug("Scope Values: {}", scopeValues);
  99         Map<String, Object> filteredScopeValues = //
 100                 scopeValues //
 101                         .entrySet() //
 102                         .stream() //
 103                         .filter(map -> !FILTERED_PRESETS.contains(map.getKey())) //
 104                         .map(JRubyScriptEngineFactory::mapInstancePresets) //
 105                         .map(JRubyScriptEngineFactory::mapGlobalPresets) //
 106                         .collect(Collectors.toMap(map -> map.getKey(), map -> map.getValue())); //
 107
 108         Map<Boolean, Map<String, Object>> partitionedMap = //
 109                 filteredScopeValues.entrySet() //
 110                         .stream() //
 111                         .collect(Collectors.partitioningBy(entry -> (entry.getValue() instanceof Class),
 112                                 Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue)));
 113
 114         importClassesToRuby(scriptEngine, partitionedMap.getOrDefault(true, new HashMap<>()));
 115         super.scopeValues(scriptEngine, partitionedMap.getOrDefault(false, new HashMap<>()));
 116     }
 117
 118     private void importClassesToRuby(ScriptEngine scriptEngine, Map<String, Object> objects) {
 119         String import_statements = objects.entrySet() //
 120                 .stream() //
 121                 .map(entry -> "java_import " + ((Class<?>) entry.getValue()).getName() + " rescue nil") //
 122                 .collect(Collectors.joining("\n"));
 123         try {
 124             scriptEngine.eval(import_statements);
 125         } catch (ScriptException e) {
 126             logger.debug("Error importing java classes", e);
 127         }
 128     }
 129
 130     @Override
 131     public @Nullable ScriptEngine createScriptEngine(String scriptType) {
 132         return scriptTypes.contains(scriptType) ? configuration.configureRubyEnvironment(factory.getScriptEngine())
 133                 : null;
 134     }
 135 }