openhab-scripting 4.47.0 → 5.0.1

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

@@ -1,28 +1,26 @@
 # frozen_string_literal: true
 
-require 'java'
-require 'openhab/core/thread_local'
-require 'openhab/log/logger'
-require 'openhab/dsl/between'
-
-require_relative 'item_event'
-
 module OpenHAB
   module DSL
-    #
-    # Creates and manages OpenHAB Rules
-    #
     module Rules
       #
-      # JRuby extension to OpenHAB Rule
+      # OpenHAB rules engine object
       #
-      # rubocop: disable Metrics/ClassLength
-      # Disabled because this class has a single responsibility, there does not appear a logical
-      # way of breaking it up into multiple classes
-      class AutomationRule < Java::OrgOpenhabCoreAutomationModuleScriptRulesupportSharedSimple::SimpleRule
-        include OpenHAB::Log
-        include OpenHAB::Core::ThreadLocal
-        include OpenHAB::DSL::Between
+      # @!visibility private
+      class AutomationRule < org.openhab.core.automation.module.script.rulesupport.shared.simple.SimpleRule
+        # @!visibility private
+        INPUT_KEY_PATTERN = /^[a-z_]+[a-zA-Z0-9_]*$/.freeze
+
+        class << self
+          #
+          # Caches dynamically generated Struct classes so that they don't have
+          # to be re-generated for every event, blowing the method cache.
+          #
+          # @!visibility private
+          # @return [java.util.Map<Array<Symbol>, Class>]
+          attr_reader :event_structs
+        end
+        @event_structs = java.util.concurrent.ConcurrentHashMap.new
 
         field_writer :uid
 
@@ -32,63 +30,96 @@ module OpenHAB
         # @param [Config] config Rule configuration
         #
         # Constructor sets a number of variables, no further decomposition necessary
-        def initialize(config:) # rubocop:disable Metrics
-          # Metrics disabled because only setters are called or defaults set.
+        #
+        def initialize(config)
           super()
           set_name(config.name)
           set_description(config.description)
-          set_tags(to_string_set(config.tags))
+          tags = DSL::Items::ItemBuilder.normalize_tags(*config.tags)
+          set_tags(tags.to_set)
           set_triggers(config.triggers)
           self.uid = config.uid
           @run_context = config.caller
           @run_queue = config.run
           @guard = config.guard
-          # Convert between to correct range or nil if not set
-          between = config.between&.then { between(config.between) }
-          @between = between
+          @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
+          debounce_settings = config.debounce_settings || { for: nil }
+          @debouncer = Debouncer.new(**debounce_settings)
         end
 
         #
         # Execute the rule
         #
-        # @param [Map] mod map provided by OpenHAB rules engine
-        # @param [Map] inputs map provided by OpenHAB rules engine containing event and other information
-        #
+        # @param [java.util.Map] mod map provided by openHAB rules engine
+        # @param [java.util.Map] inputs map provided by openHAB rules engine containing event and other information
         #
         def execute(mod = nil, inputs = nil)
-          OpenHAB::DSL.import_presets
-          thread_local(RULE_NAME: name) do
-            logger.trace { "Execute called with mod (#{mod&.to_string}) and inputs (#{inputs.inspect})" }
-            logger.trace { "Event details #{inputs['event'].inspect}" } if inputs&.key?('event')
+          execute!(mod, inputs)
+        end
+
+        # @!visibility private
+        def on_removal(listener)
+          @cleanup_hooks << listener
+          listen_for_removal unless @listener
+        end
+
+        private
+
+        # This method gets called in rspec's SuspendRules as well
+        def execute!(mod, inputs)
+          ThreadLocal.thread_local(**@thread_locals) do
+            if logger.trace?
+              logger.trace("Execute called with mod (#{mod&.to_string}) and inputs (#{inputs.inspect})")
+              logger.trace("Event details #{inputs["event"].inspect}") if inputs&.key?("event")
+            end
             trigger_conditions(inputs).process(mod: mod, inputs: inputs) do
-              process_queue(create_queue(inputs), mod, inputs)
+              event = extract_event(inputs)
+              @debouncer.call { process_queue(create_queue(event), mod, event) }
             end
+          rescue Exception => e
+            raise if defined?(::RSpec) && ::RSpec.current_example.example_group.propagate_exceptions?
+
+            @run_context.send(:logger).log_exception(e)
           end
         end
 
-        #
-        # Cleanup any resources associated with automation rule
-        #
         def cleanup
-          # No cleanup is necessary right now, trigger delays are tracked and cancelled by timers library
+          @cleanup_hooks.each(&:cleanup)
         end
 
-        private
+        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
         #
-        # @param [Map] inputs rule inputs
+        # @param [Map] event Event object
         # @return [Queue] <description>
         #
-        def create_queue(inputs)
-          case check_guards(event: extract_event(inputs))
+        def create_queue(event)
+          case check_guards(event: event)
           when true
-            @run_queue.dup.grep_v(RuleConfig::Otherwise)
+            @run_queue.dup.grep_v(BuilderDSL::Otherwise)
           when false
-            @run_queue.dup.grep(RuleConfig::Otherwise)
+            @run_queue.dup.grep(BuilderDSL::Otherwise)
           end
         end
 
@@ -101,12 +132,30 @@ module OpenHAB
         # @return [Object] event object
         #
         def extract_event(inputs)
-          event = inputs&.dig('event')
-          unless event
-            event = Struct.new(:event, :attachment, :command).new
-            event.command = inputs&.dig('command')
+          attachment = @attachments[trigger_id(inputs)]
+          if inputs&.key?("event")
+            event = inputs["event"]
+            unless event
+              if attachment
+                logger.warn("Unable to attach #{attachment.inspect} to event " \
+                            "object for rule #{uid} since the event is nil.")
+              end
+              return nil
+            end
+
+            event.attachment = attachment
+            return event
+          end
+
+          inputs = inputs.to_h
+                         .select { |key, _value| key != "module" && INPUT_KEY_PATTERN.match?(key) }
+                         .transform_keys(&:to_sym)
+          inputs[:attachment] = attachment
+          keys = inputs.keys.sort
+          struct_class = self.class.event_structs.compute_if_absent(keys) do
+            Struct.new(*keys, keyword_init: true)
           end
-          add_attachment(event, inputs)
+          struct_class.new(**inputs)
         end
 
         #
@@ -115,85 +164,61 @@ module OpenHAB
         # @return [Hash] Input hash potentially containing trigger id
         #
         def trigger_id(inputs)
-          inputs&.dig('module')
+          inputs&.dig("module")
         end
 
         #
         # Returns trigger conditions from inputs if it exists
         #
-        # @param [Map] inputs map from OpenHAB containing UID
+        # @param [java.util.Map] inputs map from openHAB containing UID
         #
         # @return [Array] Array of trigger conditions that match rule UID
         #
         def trigger_conditions(inputs)
-          # Parse this to get the trigger UID:
-          # ["72698819-83cb-498a-8e61-5aab8b812623.event", "oldState", "module", \
-          #  "72698819-83cb-498a-8e61-5aab8b812623.oldState", "event", "newState",\
-          #  "72698819-83cb-498a-8e61-5aab8b812623.newState"]
           @trigger_conditions[trigger_id(inputs)]
         end
 
-        # If an attachment exists for the trigger for this event add it to the event object
-        # @param [Object] event Event
-        # @param [Hash] inputs Inputs into event
-        # @return [Object] Event with attachment added
-        #
-        def add_attachment(event, inputs)
-          attachment = @attachments[trigger_id(inputs)]
-          return event unless attachment
-
-          event.attachment = attachment
-          event
-        end
-
         #
         # Check if any guards prevent execution
         #
-        # @param [Map] event OpenHAB rule trigger event
+        # @param [Object] event openHAB rule trigger event
         #
-        # @return [Boolean] True if guards says rule should execute, false otherwise
+        # @return [true,false] True if guards says rule should execute, false otherwise
         #
-        # rubocop:disable Metrics/MethodLength
         # Loggging inflates method length
         def check_guards(event:)
-          if @guard.should_run? event
-            return true if @between.nil?
+          return true if @guard.nil?
 
+          unless @between.nil?
             now = Time.now
-            return true if @between.cover? now
-
-            logger.trace("Skipped execution of rule '#{name}' because the current time #{now} " \
-                         "is not between #{@between.begin} and #{@between.end}")
-          else
-            logger.trace("Skipped execution of rule '#{name}' because of guard #{@guard}")
+            unless @between.cover?(now)
+              logger.trace("Skipped execution of rule '#{name}' because the current time #{now} " \
+                           "is not between #{@between.begin} and #{@between.end}")
+              return false
+            end
           end
+
+          return true if @guard.should_run?(event)
+
+          logger.trace("Skipped execution of rule '#{name}' because of guard #{@guard}")
           false
-        rescue StandardError => e
-          logger.log_exception(e, name)
         end
-        # rubocop:enable Metrics/MethodLength
 
         #
         # Process the run queue
         #
         # @param [Array] run_queue array of procs of various types to execute
-        # @param [Map] mod OpenHAB map object describing rule trigger
-        # @param [Map] inputs OpenHAB map object describing rule trigge
-        #
+        # @param [java.util/Map] mod openHAB map object describing rule trigger
+        # @param [Object] event openHAB map object describing rule trigger
         #
-        # No logical way to break this method up
-        def process_queue(run_queue, mod, inputs)
-          event = extract_event(inputs)
-
+        def process_queue(run_queue, mod, event)
           while (task = run_queue.shift)
-            if task.is_a? RuleConfig::Delay
-              process_delay_task(inputs, mod, run_queue, task)
+            if task.is_a?(BuilderDSL::Delay)
+              process_delay_task(event, mod, run_queue, task)
             else
               process_task(event, task)
             end
           end
-        rescue StandardError => e
-          logger.log_exception(e, name)
         end
 
         #
@@ -203,11 +228,12 @@ module OpenHAB
         # @param [Task] task task containing otherwise block to execute
         #
         def process_task(event, task)
-          thread_local(RULE_NAME: name) do
+          ThreadLocal.thread_local(**@thread_locals) do
             case task
-            when RuleConfig::Run then process_run_task(event, task)
-            when RuleConfig::Trigger then process_trigger_task(event, task)
-            when RuleConfig::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
@@ -227,15 +253,15 @@ module OpenHAB
         #
         # Process delay task
         #
-        # @param [Map] inputs Rule trigger inputs
+        # @param [Map] event Rule trigger event
         # @param [Map] mod Rule modes
         # @param [Queue] run_queue Queue of tasks for this rule
         # @param [Delay] task to process
         #
         #
-        def process_delay_task(inputs, mod, run_queue, task)
+        def process_delay_task(event, mod, run_queue, task)
           remaining_queue = run_queue.slice!(0, run_queue.length)
-          after(task.duration) { process_queue(remaining_queue, mod, inputs) }
+          DSL.after(task.duration) { process_queue(remaining_queue, mod, event) }
         end
 
         #
@@ -265,25 +291,13 @@ module OpenHAB
         end
 
         #
-        # Convert the given array to a set of strings.
-        # Convert Semantics classes to their simple name
+        # Process a script task
         #
-        # @example
-        #   to_string_set("tag1", Semantics::LivingRoom)
+        # @param [Script] task to execute
         #
-        # @param [Array] *tags An array of strings or Semantics classes
-        #
-        # @return [Set] A set of strings
-        #
-        def to_string_set(*tags)
-          tags = tags.flatten.map do |tag|
-            if tag.respond_to?(:java_class) && tag < org.openhab.core.semantics.Tag
-              tag.java_class.simple_name
-            else
-              tag.to_s
-            end
-          end
-          Set.new(tags)
+        def process_script_task(task)
+          logger.trace { "Executing script '#{name}' run block" }
+          @run_context.instance_exec(&task.block)
         end
 
         #
@@ -317,4 +331,3 @@ module OpenHAB
     end
   end
 end
-# rubocop: enable Metrics/ClassLength