openhab-jrubyscripting 5.0.0.rc10 → 5.0.0.rc12

data/lib/openhab/dsl/items/timed_command.rb

@@ -17,10 +17,17 @@ module OpenHAB
       # command. This is available on both the 'command' method and any
       # command-specific methods, e.g. {SwitchItem#on}.
       #
-      # Any update to the timed command state will result in the timer being
-      # cancelled. For example, if you have a Switch on a timer and another
-      # rule sends OFF or ON to that item the timer will be automatically
-      # canceled. Sending a different duration (for:) value for the timed
+      # The timer will be cancelled, and the item's state will not be changed
+      # to the on_expire state if:
+      # - The item receives any command within the timed command duration.
+      # - The item is updated to a different state, even if it is then updated
+      #   back to the same state.
+      #
+      # For example, if you have a Switch on a timer and another rule sends
+      # a command to that item, even when it's commanded to the same state,
+      # the timer will be automatically canceled.
+      #
+      # Sending a different duration (for:) value for the timed
       # command will reschedule the timed command for that new duration.
       #
       module TimedCommand
@@ -107,7 +114,7 @@ module OpenHAB
               # no prior timed command
               on_expire ||= default_on_expire(command)
               super(command)
-              create_timed_command(duration: duration, on_expire: on_expire)
+              create_timed_command(command, duration: duration, on_expire: on_expire)
             else
               timed_command_details.mutex.synchronize do
                 if timed_command_details.resolution
@@ -116,7 +123,7 @@ module OpenHAB
                   # just create a new one
                   on_expire ||= default_on_expire(command)
                   super(command)
-                  create_timed_command(duration: duration, on_expire: on_expire)
+                  create_timed_command(command, duration: duration, on_expire: on_expire)
                 else
                   # timed command still pending; reset it
                   logger.trace "Outstanding Timed Command #{timed_command_details} encountered - rescheduling"
@@ -138,13 +145,13 @@ module OpenHAB
         private
 
         # Creates a new timed command and places it in the TimedCommand hash
-        def create_timed_command(duration:, on_expire:)
+        def create_timed_command(command, duration:, on_expire:)
           timed_command_details = TimedCommandDetails.new(item: self,
                                                           on_expire: on_expire,
                                                           mutex: Mutex.new)
 
           timed_command_details.timer = timed_command_timer(timed_command_details, duration)
-          cancel_rule = TimedCommandCancelRule.new(timed_command_details)
+          cancel_rule = TimedCommandCancelRule.new(command, timed_command_details)
           unmanaged_rule = Core.automation_manager.add_unmanaged_rule(cancel_rule)
           timed_command_details.rule_uid = unmanaged_rule.uid
           Core::Rules::Provider.current.add(unmanaged_rule)
@@ -189,16 +196,27 @@ module OpenHAB
         #
         # @!visibility private
         class TimedCommandCancelRule < org.openhab.core.automation.module.script.rulesupport.shared.simple.SimpleRule
-          def initialize(timed_command_details)
+          def initialize(command, timed_command_details)
             super()
             @timed_command_details = timed_command_details
             # Capture rule name if known
             @thread_locals = ThreadLocal.persist
             self.name = "Cancel implicit timer for #{timed_command_details.item.name}"
-            self.triggers = [Rules::RuleTriggers.trigger(
-              type: Rules::Triggers::Changed::ITEM_STATE_CHANGE,
-              config: { "itemName" => timed_command_details.item.name }
-            )]
+            self.triggers = [
+              Rules::RuleTriggers.trigger(
+                type: Rules::Triggers::Changed::ITEM_STATE_CHANGE,
+                config: {
+                  "itemName" => timed_command_details.item.name,
+                  "previousState" => timed_command_details.item.format_command(command).to_s
+                }
+              ),
+              Rules::RuleTriggers.trigger(
+                type: Rules::Triggers::Command::ITEM_COMMAND,
+                config: {
+                  "itemName" => timed_command_details.item.name
+                }
+              )
+            ]
             self.visibility = Core::Rules::Visibility::HIDDEN
           end
 

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

@@ -30,12 +30,13 @@ module OpenHAB
         # @param [Config] config Rule configuration
         #
         # Constructor sets a number of variables, no further decomposition necessary
+        #
         def initialize(config)
-          # Metrics disabled because only setters are called or defaults set.
           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
@@ -50,6 +51,8 @@ module OpenHAB
           @thread_locals = ThreadLocal.persist
           @cleanup_hooks = Set.new
           @listener = nil
+          debounce_settings = config.debounce_settings || { for: nil }
+          @debouncer = Debouncer.new(**debounce_settings)
         end
 
         #
@@ -58,30 +61,34 @@ module OpenHAB
         # @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)
+          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
             logger.trace { "Execute called with mod (#{mod&.to_string}) and inputs (#{inputs.inspect})" }
             logger.trace { "Event details #{inputs["event"].inspect}" } if inputs&.key?("event")
             trigger_conditions(inputs).process(mod: mod, inputs: inputs) do
               event = extract_event(inputs)
-              process_queue(create_queue(event), mod, event)
+              @debouncer.call { process_queue(create_queue(event), mod, event) }
             end
           rescue Exception => e
-            raise if defined?(::RSpec)
+            raise if defined?(::RSpec) && ::RSpec.current_example.example_group.propagate_exceptions?
 
             @run_context.send(:logger).log_exception(e)
           end
         end
 
-        # @!visibility private
-        def on_removal(listener)
-          @cleanup_hooks << listener
-          listen_for_removal unless @listener
-        end
-
-        private
-
         def cleanup
           @cleanup_hooks.each(&:cleanup)
         end
@@ -180,17 +187,18 @@ module OpenHAB
         def check_guards(event:)
           return true if @guard.nil?
 
-          if @guard.should_run? event
-            return true if @between.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
         end
 
@@ -290,28 +298,6 @@ module OpenHAB
           @run_context.instance_exec(&task.block)
         end
 
-        #
-        # Convert the given array to a set of strings.
-        # Convert Semantics classes to their simple name
-        #
-        # @example
-        #   to_string_set("tag1", Semantics::LivingRoom)
-        #
-        # @param tags [Array] 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)
-        end
-
         #
         # Create a new hash in which all elements are converted to strings
         #