openhab-jrubyscripting 5.0.0.rc1 → 5.0.0.rc3

data/lib/openhab/dsl/rules/automation_rule.rb

@@ -16,7 +16,7 @@ module OpenHAB
         # @param [Config] config Rule configuration
         #
         # Constructor sets a number of variables, no further decomposition necessary
-        def initialize(config:)
+        def initialize(config)
           # Metrics disabled because only setters are called or defaults set.
           super()
           set_name(config.name)
@@ -29,8 +29,13 @@ module OpenHAB
           @guard = config.guard
           @between = config.between && DSL.between(config.between)
           @trigger_conditions = config.trigger_conditions
+          @trigger_conditions.each_value do |condition|
+            condition.rule = self if condition.respond_to?(:rule=)
+          end
           @attachments = config.attachments
           @thread_locals = ThreadLocal.persist
+          @cleanup_hooks = Set.new
+          @listener = nil
         end
 
         #
@@ -48,19 +53,37 @@ module OpenHAB
               process_queue(create_queue(inputs), mod, inputs)
             end
           rescue Exception => e
+            raise if defined?(::RSpec)
+
             @run_context.send(:logger).log_exception(e)
           end
         end
 
-        #
-        # Cleanup any resources associated with automation rule
-        #
-        def cleanup
-          @trigger_conditions.each_value(&:cleanup)
+        # @!visibility private
+        def on_removal(listener)
+          @cleanup_hooks << listener
+          listen_for_removal unless @listener
         end
 
         private
 
+        def cleanup
+          @cleanup_hooks.each(&:cleanup)
+        end
+
+        def listen_for_removal
+          @listener ||= org.openhab.core.common.registry.RegistryChangeListener.impl do |method, element|
+            next unless method == :removed
+
+            logger.trace("Rule #{element.inspect} removed from registry")
+            next unless element.uid == uid
+
+            cleanup
+            $rules.remove_registry_change_listener(@listener)
+          end
+          $rules.add_registry_change_listener(@listener)
+        end
+
         #
         # Create the run queue based on guards
         #
@@ -70,9 +93,9 @@ module OpenHAB
         def create_queue(inputs)
           case check_guards(event: extract_event(inputs))
           when true
-            @run_queue.dup.grep_v(Builder::Otherwise)
+            @run_queue.dup.grep_v(BuilderDSL::Otherwise)
           when false
-            @run_queue.dup.grep(Builder::Otherwise)
+            @run_queue.dup.grep(BuilderDSL::Otherwise)
           end
         end
 
@@ -166,7 +189,7 @@ module OpenHAB
           event = extract_event(inputs)
 
           while (task = run_queue.shift)
-            if task.is_a?(Builder::Delay)
+            if task.is_a?(BuilderDSL::Delay)
               process_delay_task(inputs, mod, run_queue, task)
             else
               process_task(event, task)
@@ -183,10 +206,10 @@ module OpenHAB
         def process_task(event, task)
           ThreadLocal.thread_local(**@thread_locals) do
             case task
-            when Builder::Run then process_run_task(event, task)
-            when Builder::Script then process_script_task(task)
-            when Builder::Trigger then process_trigger_task(event, task)
-            when Builder::Otherwise then process_otherwise_task(event, task)
+            when BuilderDSL::Run then process_run_task(event, task)
+            when BuilderDSL::Script then process_script_task(task)
+            when BuilderDSL::Trigger then process_trigger_task(event, task)
+            when BuilderDSL::Otherwise then process_otherwise_task(event, task)
             end
           end
         end

data/lib/openhab/dsl/rules/builder.rb

@@ -5,6 +5,7 @@ require "forwardable"
 require_relative "property"
 require_relative "guard"
 require_relative "rule_triggers"
+require_relative "terse"
 
 Dir[File.expand_path("triggers/*.rb", __dir__)].sort.each do |f|
   require f
@@ -16,10 +17,100 @@ module OpenHAB
     # Creates and manages OpenHAB Rules
     #
     module Rules
+      # A rules builder allows you to create OpenHAB rules.
       #
-      # Rule configuration for OpenHAB Rules engine
+      # Note that all methods on this module are also availabe directly on {OpenHAB::DSL}.
       #
       class Builder
+        include Terse
+
+        # @return [org.openhab.core.automation.RuleProvider]
+        attr_reader :provider
+
+        def initialize(provider)
+          @provider = Core::Rules::Provider.current(provider)
+        end
+
+        #
+        # Create a new rule
+        #
+        # @param [String] name The rule name
+        # @yield Block executed in the context of a {Rules::Builder}
+        # @yieldparam [Rules::Builder] rule
+        #   Optional parameter to access the rule configuration from within execution blocks and guards.
+        # @return [Rule]
+        #
+        # @see OpenHAB::DSL::Rules::Builder Rule builder for details on rule triggers, guards and execution blocks
+        # @see Rules::Terse Terse Rules
+        #
+        # @example
+        #   require "openhab/dsl"
+        #
+        #   rule "name" do
+        #     <zero or more triggers>
+        #     <zero or more execution blocks>
+        #     <zero or more guards>
+        #   end
+        #
+        def rule(name = nil, id: nil, script: nil, binding: nil, &block)
+          raise ArgumentError, "Block is required" unless block
+
+          id ||= NameInference.infer_rule_id_from_block(block)
+          script ||= block.source rescue nil # rubocop:disable Style/RescueModifier
+
+          builder = nil
+
+          ThreadLocal.thread_local(openhab_rule_type: "rule", openhab_rule_uid: id) do
+            builder = BuilderDSL.new(binding || block.binding)
+            builder.uid(id)
+            builder.instance_exec(builder, &block)
+            builder.guard = Guard.new(run_context: builder.caller, only_if: builder.only_if,
+                                      not_if: builder.not_if)
+
+            name ||= NameInference.infer_rule_name(builder)
+            name ||= id
+
+            builder.name(name)
+            logger.trace { builder.inspect }
+            builder.build(provider, script)
+          end
+        end
+
+        #
+        # Create a new script
+        #
+        # A script is a rule with no triggers. It can be called by various other actions,
+        # such as the Run Rules action.
+        #
+        # @param [String] name A descriptive name
+        # @param [String] id The script's ID
+        # @yield [] Block executed when the script is executed.
+        # @return [Rule]
+        #
+        def script(name = nil, id: nil, script: nil, &block)
+          raise ArgumentError, "Block is required" unless block
+
+          id ||= NameInference.infer_rule_id_from_block(block)
+          name ||= id
+          script ||= block.source rescue nil # rubocop:disable Style/RescueModifier
+
+          builder = nil
+          ThreadLocal.thread_local(openhab_rule_type: "script", openhab_rule_uid: id) do
+            builder = BuilderDSL.new(block.binding)
+            builder.uid(id)
+            builder.tags(["Script"])
+            builder.name(name)
+            builder.script(&block)
+            logger.trace { builder.inspect }
+            builder.build(provider, script)
+          end
+        end
+      end
+
+      #
+      # Rule configuration for OpenHAB Rules engine
+      #
+      class BuilderDSL
         include Core::EntityLookup
         include DSL
         prepend Triggers
@@ -703,6 +794,16 @@ module OpenHAB
 
           @ruby_triggers << [:changed, items, { to: to, from: from, duration: duration }]
           items.each do |item|
+            case item
+            when Core::Things::Thing,
+                 Core::Things::ThingUID,
+                 Core::Items::GenericItem,
+                 Core::Items::GroupItem::Members
+              nil
+            else
+              raise ArgumentError, "items must be a GenericItem, GroupItem::Members, Thing, or ThingUID"
+            end
+
             logger.trace("Creating changed trigger for entity(#{item}), to(#{to.inspect}), from(#{from.inspect})")
 
             Array.wrap(from).each do |from_state|
@@ -970,6 +1071,13 @@ module OpenHAB
           @ruby_triggers << [:received_command, items, { command: commands }]
 
           items.each do |item|
+            case item
+            when Core::Items::GenericItem,
+                 Core::Items::GroupItem::Members
+              nil
+            else
+              raise ArgumentError, "items must be a GenericItem or GroupItem::Members"
+            end
             commands.each do |cmd|
               logger.trace "Creating received command trigger for items #{item.inspect} and commands #{cmd.inspect}"
 
@@ -1160,6 +1268,16 @@ module OpenHAB
           updated = Updated.new(rule_triggers: @rule_triggers)
           @ruby_triggers << [:updated, items, { to: to }]
           items.map do |item|
+            case item
+            when Core::Things::Thing,
+                 Core::Things::ThingUID,
+                 Core::Items::GenericItem,
+                 Core::Items::GroupItem::Members
+              nil
+            else
+              raise ArgumentError, "items must be a GenericItem, GroupItem::Members, Thing, or ThingUID"
+            end
+
             logger.trace("Creating updated trigger for item(#{item}) to(#{to})")
             [to].flatten.map do |to_state|
               updated.trigger(item: item, to: to_state, attach: attach)
@@ -1292,12 +1410,11 @@ module OpenHAB
         # @param [String] script The source code of the rule
         #
         # @!visibility private
-        def build(script)
+        def build(provider, script)
           return unless create_rule?
 
-          rule = AutomationRule.new(config: self)
-          added_rule = add_rule(rule)
-          Rules.script_rules[rule.uid] = rule
+          rule = AutomationRule.new(self)
+          added_rule = add_rule(provider, rule)
           # add config so that MainUI can show the script
           added_rule.actions.first.configuration.put("type", "application/x-ruby")
           added_rule.actions.first.configuration.put("script", script)
@@ -1356,8 +1473,7 @@ module OpenHAB
         #
         # @param [org.openhab.core.automation.module.script.rulesupport.shared.simple.SimpleRule] rule to add
         #
-        #
-        def add_rule(rule)
+        def add_rule(provider, rule)
           base_uid = rule.uid
           duplicate_index = 1
           while $rules.get(rule.uid)
@@ -1365,7 +1481,9 @@ module OpenHAB
             rule.uid = "#{base_uid} (#{duplicate_index})"
           end
           logger.trace("Adding rule: #{rule}")
-          Core.automation_manager.add_rule(rule)
+          unmanaged_rule = Core.automation_manager.add_unmanaged_rule(rule)
+          provider.add(unmanaged_rule)
+          unmanaged_rule
         end
       end
     end

data/lib/openhab/dsl/rules/name_inference.rb

@@ -23,11 +23,6 @@ module OpenHAB
         private_constant :KNOWN_TRIGGER_TYPES
 
         class << self
-          # takes a freeform rule name and makes it more palatable as an id
-          def infer_rule_id_from_name(name)
-            name.downcase.delete("'\"").gsub(/\W+/, "_")
-          end
-
           # get the block's source location, and simplify to a simple filename
           def infer_rule_id_from_block(block)
             file = File.basename(block.source_location.first)

data/lib/openhab/dsl/rules/terse.rb

@@ -26,13 +26,12 @@ module OpenHAB
           #   @param id [String] The ID for the rule.
           #   @yield The execution block for the rule.
           #   @return [void]
-          #   @see Builder#$1
+          #   @see BuilderDSL#$1
           def def_terse_rule(trigger)
             class_eval(<<~RUBY, __FILE__, __LINE__ + 1)
               def #{trigger}(*args, name: nil, id: nil, **kwargs, &block)     # def changed(*args, name: nil, id: nil, **kwargs, &block)
                 raise ArgumentError, "Block is required" unless block         #   raise ArgumentError, "Block is required" unless block
                                                                               #
-                id ||= NameInference.infer_rule_id_from_name(name) if name    #   id ||= NameInference.infer_rule_id_from_name(name) if name
                 id ||= NameInference.infer_rule_id_from_block(block)          #   id ||= NameInference.infer_rule_id_from_block(block)
                 script = block.source rescue nil                              #   script = block.source rescue nil
                 caller_binding = block.binding                                #   caller_binding = block.binding

data/lib/openhab/dsl/rules/triggers/changed.rb

@@ -107,10 +107,13 @@ module OpenHAB
           #
           def changed_trigger(item:, from:, to:, attach: nil, conditions: nil)
             type, config = case item
-                           when GroupItem::Members then group(group: item, from: from,
-                                                              to: to)
-                           when Core::Things::Thing then thing(thing: item, from: from, to: to)
-                           else item(item: item, from: from, to: to)
+                           when GroupItem::Members
+                             group(group: item, from: from, to: to)
+                           when Core::Things::Thing,
+                                Core::Things::ThingUID
+                             thing(thing: item, from: from, to: to)
+                           else
+                             item(item: item, from: from, to: to)
                            end
             append_trigger(type: type, config: config, attach: attach, conditions: conditions)
           end

data/lib/openhab/dsl/rules/triggers/conditions/duration.rb

@@ -6,19 +6,12 @@ module OpenHAB
       module Triggers
         # @!visibility private
         module Conditions
-          #
-          # this is a no-op condition which simply executes the provided block
-          #
-
           #
           # Struct capturing data necessary for a conditional trigger
           #
-          # TriggerDelay = Struct.new(:to, :from, :duration, :timer, :tracking_to, keyword_init: true) do
-          #  def timer_active?
-          #    timer&.active?
-          #  end
-          # end
           class Duration
+            attr_accessor :rule
+
             #
             # Create a new duration condition
             # @param [Object] to optional condition on to state
@@ -39,7 +32,17 @@ module OpenHAB
             # @param [Hash] inputs inputs from trigger
             #
             def process(mod:, inputs:, &block)
-              process_trigger_delay(mod, inputs, &block)
+              if @timer&.active?
+                process_active_timer(inputs, mod, &block)
+              elsif check_trigger_guards(inputs)
+                logger.trace("Trigger Guards Matched for #{self}, delaying rule execution")
+                # Add timer and attach timer to delay object, and also state being tracked to so
+                # timer can be cancelled if state changes
+                # Also another timer should not be created if changed to same value again but instead rescheduled
+                create_trigger_delay_timer(inputs, mod, &block)
+              else
+                logger.trace("Trigger Guards did not match for #{self}, ignoring trigger.")
+              end
             end
 
             # Cleanup any resources from the condition
@@ -51,13 +54,6 @@ module OpenHAB
 
             private
 
-            #
-            # Checks if there is an active timer
-            # @return [true, false] true if the timer exists and is active, false otherwise
-            def timer_active?
-              @timer&.active?
-            end
-
             #
             # Check if trigger guards prevent rule execution
             #
@@ -79,44 +75,12 @@ module OpenHAB
             # @return [Array] An array of the values for [newState, oldState] or [newStatus, oldStatus]
             #
             def retrieve_states(inputs)
-              new_state = inputs["newState"] || thing_status_to_sym(inputs["newStatus"])
-              old_state = inputs["oldState"] || thing_status_to_sym(inputs["oldStatus"])
+              new_state = inputs["newState"] || inputs["newStatus"]&.to_s&.downcase&.to_sym
+              old_state = inputs["oldState"] || inputs["oldStatus"]&.to_s&.downcase&.to_sym
 
               [new_state, old_state]
             end
 
-            #
-            # Converts a ThingStatus object to a ruby Symbol
-            #
-            # @param [org.openhab.core.thing.ThingStatus] status A ThingStatus instance
-            #
-            # @return [Symbol] A corresponding symbol, in lower case
-            #
-            def thing_status_to_sym(status)
-              status&.to_s&.downcase&.to_sym
-            end
-
-            #
-            # Process any matching trigger delays
-            #
-            # @param [Map] mod OpenHAB map object describing rule trigger
-            # @param [Map] inputs OpenHAB map object describing rule trigger
-            #
-            #
-            def process_trigger_delay(mod, inputs, &block)
-              if timer_active?
-                process_active_timer(inputs, mod, &block)
-              elsif check_trigger_guards(inputs)
-                logger.trace("Trigger Guards Matched for #{self}, delaying rule execution")
-                # Add timer and attach timer to delay object, and also state being tracked to so
-                # timer can be cancelled if state changes
-                # Also another timer should not be created if changed to same value again but instead rescheduled
-                create_trigger_delay_timer(inputs, mod, &block)
-              else
-                logger.trace("Trigger Guards did not match for #{self}, ignoring trigger.")
-              end
-            end
-
             #
             # Creates a timer for trigger delays
             #
@@ -131,6 +95,7 @@ module OpenHAB
                 @timer = nil
                 yield
               end
+              rule.on_removal(self)
               @tracking_to, = retrieve_states(inputs)
             end
 
@@ -140,7 +105,6 @@ module OpenHAB
             # @param [Hash] inputs rule trigger inputs
             # @param [Hash] mod rule trigger mods
             #
-            #
             def process_active_timer(inputs, mod, &block)
               state, = retrieve_states(inputs)
               if state == @tracking_to
@@ -150,7 +114,7 @@ module OpenHAB
                 logger.trace("Item changed to #{state} for #{self}, canceling timer.")
                 @timer.cancel
                 # Reprocess trigger delay after canceling to track new state (if guards matched, etc)
-                process_trigger_delay(mod, inputs, &block)
+                process(mod: mod, inputs: inputs, &block)
               end
             end
           end

data/lib/openhab/dsl/rules/triggers/conditions/proc.rb

@@ -84,9 +84,6 @@ module OpenHAB
               yield if check_procs(inputs: inputs)
             end
 
-            # Cleanup any resources from the condition
-            def cleanup; end
-
             #
             # Check if command condition match the proc
             # @param [Hash] inputs from trigger must be supplied if state is not supplied

data/lib/openhab/dsl/rules/triggers/cron/cron.rb

@@ -11,7 +11,7 @@ module OpenHAB
         # Creates cron triggers
         #
         class Cron < Trigger
-          # Trigger ID for Watch Triggers
+          # Trigger ID for Cron Triggers
           CRON_TRIGGER_MODULE_ID = "jsr223.jruby.CronTrigger"
 
           #

data/lib/openhab/dsl/rules/triggers/trigger.rb

@@ -33,7 +33,7 @@ module OpenHAB
           # @return [Array] Trigger and config for thing
           #
           def trigger_for_thing(thing:, type:, to: nil, from: nil)
-            config = { "thingUID" => thing.uid.to_s }
+            config = { "thingUID" => thing.to_s }
             config["status"] = trigger_state_from_symbol(to).to_s if to
             config["previousStatus"] = trigger_state_from_symbol(from).to_s if from
             [type, config]

data/lib/openhab/dsl/rules/triggers/updated.rb

@@ -74,9 +74,13 @@ module OpenHAB
           #
           def update_trigger(item:, to:, attach: nil, conditions: nil)
             type, config = case item
-                           when GroupItem::Members then group_update(item: item, to: to)
-                           when Core::Things::Thing then thing_update(thing: item, to: to)
-                           else item_update(item: item, to: to)
+                           when GroupItem::Members
+                             group_update(item: item, to: to)
+                           when Core::Things::Thing,
+                                Core::Things::ThingUID
+                             thing_update(thing: item, to: to)
+                           else
+                             item_update(item: item, to: to)
                            end
             append_trigger(type: type, config: config, attach: attach, conditions: conditions)
           end

data/lib/openhab/dsl/rules/triggers/watch/watch_handler.rb

@@ -98,8 +98,8 @@ module OpenHAB
             #
             def watch_event_handler(glob)
               lambda { |watch_event|
-                logger.trace("Received event(#{watch_event})")
                 if watch_event.path.fnmatch?(glob)
+                  logger.trace("Received event(#{watch_event})")
                   @rule_engine_callback&.triggered(@trigger, { "event" => watch_event })
                 else
                   logger.trace("Event #{watch_event} did not match glob(#{glob})")

data/lib/openhab/dsl/rules.rb

@@ -1,29 +1,8 @@
 # frozen_string_literal: true
 
-require_relative "script_handling"
-
 module OpenHAB
   module DSL
     module Rules
-      @script_rules = {}
-
-      @scripted_rule_provider = OSGi.service(
-        "org.openhab.core.automation.module.script.rulesupport.shared.ScriptedRuleProvider"
-      )
-      class << self
-        # @!visibility private
-        attr_reader :script_rules, :scripted_rule_provider
-
-        #
-        # Cleanup rules in this script file
-        #
-        # @return [void]
-        #
-        def cleanup_rules
-          script_rules.each_value(&:cleanup)
-        end
-      end
-      ScriptHandling.script_unloaded { cleanup_rules }
     end
   end
 end

data/lib/openhab/dsl/script_handling.rb

@@ -2,54 +2,5 @@
 
 module OpenHAB
   module DSL
-    #
-    # Provide callback mechanisms for script handling
-    #
-    module ScriptHandling
-      module_function
-
-      #
-      # Add a block of code to be executed once the rule script has finished loading.
-      #
-      # This can occur on OpenHAB start up, when the script is first created, or updated.
-      #
-      # Multiple hooks can be added by calling {#script_loaded} multiple times.
-      # They can be used to perform final initializations.
-      #
-      # @return [void]
-      #
-      # @example
-      #   script_loaded do
-      #     logger.info 'Hi, this script has just finished loading'
-      #   end
-      #
-      # @example
-      #   script_loaded do
-      #     logger.info 'I will be called after the script finished loading too'
-      #   end
-      #
-      def script_loaded(&block)
-        Core::ScriptHandlingCallbacks.script_loaded_hooks << block
-      end
-
-      #
-      # Add a block of code to be executed when the script is unloaded.
-      #
-      # This can occur when OpenHAB shuts down, or when the script is being reloaded.
-      #
-      # Multiple hooks can be added by calling {#script_unloaded} multiple times.
-      # They can be used to perform final cleanup.
-      #
-      # @return [void]
-      #
-      # @example
-      #   script_unloaded do
-      #     logger.info 'Hi, this script has been unloaded'
-      #   end
-      #
-      def script_unloaded(&block)
-        Core::ScriptHandlingCallbacks.script_unloaded_hooks << block
-      end
-    end
   end
 end

data/lib/openhab/dsl/things/builder.rb

@@ -6,36 +6,6 @@ module OpenHAB
     # Contains extensions to simplify working with {Core::Things::Thing Thing}s.
     #
     module Things
-      # Stores all things created in scripts, and notifies the ThingRegistry
-      # of their existence
-      # aa@!visibility private
-      class ThingProvider < org.openhab.core.common.registry.AbstractProvider
-        include org.openhab.core.thing.ThingProvider
-        include Singleton
-
-        def initialize
-          super
-
-          @things = []
-
-          $things.add_provider(self)
-          ScriptHandling.script_unloaded { $things.remove_provider(self) }
-        end
-
-        # Add a thing to this provider
-        def add(thing)
-          thing = thing.build
-          @things << thing
-          notify_listeners_about_added_element(thing)
-          thing
-        end
-
-        # Get all items in this provider
-        def getAll # rubocop:disable Naming/MethodName required by java interface
-          @things
-        end
-      end
-
       # A thing builder allows you to dynamically create OpenHAB thing at runtime.
       # This can be useful either to create things as soon as the script loads,
       # or even later based on a rule executing.
@@ -45,6 +15,13 @@ module OpenHAB
       #     thing "astro:sun:home", "Astro Sun Data", config: { "geolocation" => "0,0" }
       #   end
       class Builder
+        # @return [org.openhab.core.things.ManagedThingProvider]
+        attr_reader :provider
+
+        def initialize(provider)
+          @provider = Core::Things::Provider.current(provider)
+        end
+
         # Create a new Bridge
         # @see BridgeBuilder#initialize
         def bridge(*args, **kwargs, &block)
@@ -62,7 +39,7 @@ module OpenHAB
         def build(klass, *args, **kwargs, &block)
           builder = klass.new(*args, **kwargs)
           builder.instance_eval(&block) if block
-          thing = ThingProvider.instance.add(builder)
+          thing = provider.add(builder.build)
           thing = Core::Things::Proxy.new(thing)
           thing.enable(enabled: builder.enabled) unless builder.enabled.nil?
           thing