openhab-scripting 5.16.0 → 5.18.0

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

@@ -40,7 +40,17 @@ module OpenHAB
         # The rule must have at least one trigger and one execution block.
         # To create a "script" without any triggers, use {OpenHAB::DSL.script script}.
         #
+        # When explicit `id` is not provided, the rule's ID will be inferred from the block's source location,
+        # and a suffix will be added to avoid clashing against existing rules.
+        #
+        # When an explicit `id` is provided and an existing rule with the same id already exists,
+        # the rule will not be created, and the method will return nil.
+        #
+        # To ensure that a rule is created even when the same id already exists, use {OpenHAB::DSL.rule!} or call
+        # {Core::Rules::Registry#remove rules.remove} to remove any existing rule prior to creating the new rule.
+        #
         # @param [String] name The rule name
+        # @param [String] id The rule's ID. This can also be defined in the block using {Rules::BuilderDSL#uid uid}.
         # @yield Block executed in the context of a {Rules::BuilderDSL}
         # @yieldparam [Rules::BuilderDSL] rule
         #   Optional parameter to access the rule configuration from within execution blocks and guards.
@@ -48,20 +58,26 @@ module OpenHAB
         #
         # @see OpenHAB::DSL::Rules::BuilderDSL Rule BuilderDSL for details on rule triggers, guards and execution blocks
         # @see Rules::Terse Terse Rules
+        # @see DSL.rule!
         #
         # @example
-        #   require "openhab/dsl"
-        #
         #   rule "name" do
         #     <one or more triggers>
         #     <one or more execution blocks>
         #     <zero or more guards>
         #   end
         #
-        def rule(name = nil, id: nil, script: nil, binding: nil, &block)
+        # @example Create a rule with an explicit id, deleting any existing rule with the same id
+        #   rule! "name", id: "my_happy_day_reminder" do
+        #     every :day
+        #     run { logger.info "Happy new day!" }
+        #   end
+        #
+        def rule(name = nil, id: nil, replace: false, script: nil, binding: nil, &block)
           raise ArgumentError, "Block is required" unless block
 
-          id ||= NameInference.infer_rule_id_from_block(block)
+          inferred_id = nil
+          id ||= inferred_id = NameInference.infer_rule_id_from_block(block)
           script ||= block.source rescue nil # rubocop:disable Style/RescueModifier
 
           builder = nil
@@ -70,6 +86,18 @@ module OpenHAB
             builder = BuilderDSL.new(binding || block.binding)
             builder.uid(id)
             builder.instance_exec(builder, &block)
+
+            if replace
+              logger.debug { "Removing existing rule '#{builder.uid}'." } if DSL.rules.remove(builder.uid)
+            else
+              id_not_inferred = inferred_id.nil? || inferred_id != builder.uid
+              if id_not_inferred && (existing_rule = $rules.get(builder.uid))
+                logger.warn "Rule '#{builder.uid}' is not created because " \
+                            "another rule/script/scene with the same id already exists: #{existing_rule.inspect}."
+                return nil
+              end
+            end
+
             builder.guard = Guard.new(run_context: builder.caller,
                                       only_if: builder.only_if,
                                       not_if: builder.not_if)
@@ -101,7 +129,7 @@ module OpenHAB
         # @param [String, Symbol, Semantics::Tag, Array<String, Symbol, Semantics::Tag>, nil] tags
         #   Fluent alias for `tag`
         # @yield [] Block executed when the script is executed.
-        # @return [Core::Rules::Rule]
+        # @return [Core::Rules::Rule, nil]
         #
         # @example A simple script
         #   # return the script object into a variable
@@ -123,15 +151,26 @@ module OpenHAB
         #
         #   rules.scripts["send_alert"].run(message: "The door is open!")
         #
+        # @see DSL.rule
         # @see Core::Rules::Rule#trigger
+        # @see DSL.script!
         #
-        def script(name = nil, description: nil, id: nil, tag: nil, tags: nil, script: nil, &block)
+        def script(name = nil, description: nil, id: nil, tag: nil, tags: nil, replace: false, script: nil, &block)
           raise ArgumentError, "Block is required" unless block
 
-          id ||= NameInference.infer_rule_id_from_block(block)
+          inferred_id = nil # rubocop:disable Lint/UselessAssignment it is used below
+          id ||= inferred_id = NameInference.infer_rule_id_from_block(block)
           name ||= id
           script ||= block.source rescue nil # rubocop:disable Style/RescueModifier
 
+          if replace
+            logger.debug { "Removing existing rule '#{id}'." } if DSL.rules.remove(id)
+          elsif inferred_id.nil? && (existing_rule = $rules.get(id))
+            logger.warn "Script '#{id}' is not created because " \
+                        "another script/scene/rule with the same id already exists: #{existing_rule.inspect}."
+            return nil
+          end
+
           builder = nil
           ThreadLocal.thread_local(openhab_rule_type: "script", openhab_rule_uid: id) do
             builder = BuilderDSL.new(block.binding)
@@ -159,15 +198,27 @@ module OpenHAB
         # @param [String, Symbol, Semantics::Tag, Array<String, Symbol, Semantics::Tag>, nil] tags
         #   Fluent alias for `tag`
         # @yield [] Block executed when the script is executed.
-        # @return [Core::Rules::Rule]
+        # @return [Core::Rules::Rule, nil]
         #
-        def scene(name = nil, description: nil, id: nil, tag: nil, tags: nil, script: nil, &block)
+        # @see DSL.rule
+        # @see DSL.scene!
+        #
+        def scene(name = nil, description: nil, id: nil, tag: nil, tags: nil, replace: false, script: nil, &block)
           raise ArgumentError, "Block is required" unless block
 
-          id ||= NameInference.infer_rule_id_from_block(block)
+          inferred_id = nil # rubocop:disable Lint/UselessAssignment
+          id ||= inferred_id = NameInference.infer_rule_id_from_block(block)
           name ||= id
           script ||= block.source rescue nil # rubocop:disable Style/RescueModifier
 
+          if replace
+            logger.debug { "Removing existing rule '#{id}'." } if DSL.rules.remove(id)
+          elsif inferred_id.nil? && (existing_rule = $rules.get(id))
+            logger.warn "Scene '#{id}' is not created because " \
+                        "another script/scene/rule with the same id already exists: #{existing_rule.inspect}."
+            return nil
+          end
+
           builder = nil
           ThreadLocal.thread_local(openhab_rule_type: "script", openhab_rule_uid: id) do
             builder = BuilderDSL.new(block.binding)
@@ -400,7 +451,7 @@ module OpenHAB
         # @param [String] id
         # @return [void]
         #
-        prop :uid
+        prop(:uid) { |id| Thread.current[:openhab_rule_uid] = id }
 
         #
         # @!method name(value)
@@ -994,13 +1045,20 @@ module OpenHAB
         # @param [Item, GroupItem::Members, Thing] items Objects to create trigger for.
         # @param [State, Array<State>, #===, nil] from
         #   Only execute rule if previous state matches `from` state(s).
-        # @param [State, Array<State>, #===, nil] to State(s) for
+        # @param [State, Array<State>, #===, nil] to
         #   Only execute rule if new state matches `to` state(s).
-        # @param [java.time.temporal.TemporalAmount] for
-        #   Duration item must remain in the same state before executing the execution blocks.
-        # @param [Object] attach object to be attached to the trigger
+        # @param [java.time.temporal.TemporalAmount, Proc, nil] for
+        #   Duration for which the item/thing must remain in the same state before executing the execution blocks.
+        #   When a proc is provided, it will be called when the rule is triggered to get the duration.
+        # @param [Object, nil] attach object to be attached to the trigger
         # @return [void]
         #
+        # @example Single item trigger
+        #   rule "Execute rule when a sensor changed" do
+        #     changed FrontMotion_Sensor
+        #     run { |event| logger.info("Motion detected by #{event.item.name}") }
+        #   end
+        #
         # @example Multiple items can be separated with a comma:
         #   rule "Execute rule when either sensor changed" do
         #     changed FrontMotion_Sensor, RearMotion_Sensor
@@ -1013,23 +1071,15 @@ module OpenHAB
         #     run { |event| logger.info("Motion detected by #{event.item.name}") }
         #   end
         #
-        # @example `for` parameter can be a proc too:
-        #   Alarm_Delay << 20
-        #
-        #   rule "Execute rule when item is changed for specified duration" do
-        #     changed Alarm_Mode, for: -> { Alarm_Delay.state }
-        #     run { logger.info("Alarm Mode Updated") }
-        #   end
-        #
-        # @example You can optionally provide `from` and `to` states to restrict the cases in which the rule executes:
-        #   rule "Execute rule when item is changed to specific number, from specific number, for specified duration" do
-        #     changed Alarm_Mode, from: 8, to: [14,12], for: 12.seconds
+        # @example You can optionally provide `from` and/or `to` states to restrict the cases in which the rule executes:
+        #   rule "Execute rule when item is changed to specific number, from specific number" do
+        #     changed Alarm_Mode, from: 8, to: [14,12]
         #     run { logger.info("Alarm Mode Updated") }
         #   end
         #
         # @example Works with ranges:
-        #   rule "Execute when item changed to a range of numbers, from a range of numbers, for specified duration" do
-        #     changed Alarm_Mode, from: 8..10, to: 12..14, for: 12.seconds
+        #   rule "Execute when item changed to a range of numbers, from a range of numbers" do
+        #     changed Alarm_Mode, from: 8..10, to: 12..14
         #     run { logger.info("Alarm Mode Updated") }
         #   end
         #
@@ -1040,14 +1090,14 @@ module OpenHAB
         #   end
         #
         # @example Works with procs:
-        #   rule "Execute when item state is changed from an odd number, to an even number, for specified duration" do
-        #     changed Alarm_Mode, from: proc { |from| from.odd? }, to: proc {|to| to.even? }, for: 12.seconds
+        #   rule "Execute when item state is changed from an odd number, to an even number" do
+        #     changed Alarm_Mode, from: proc { |from| from.odd? }, to: proc {|to| to.even? }
         #     run { logger.info("Alarm Mode Updated") }
         #   end
         #
         # @example Works with lambdas:
-        #   rule "Execute when item state is changed from an odd number, to an even number, for specified duration" do
-        #     changed Alarm_Mode, from: -> from { from.odd? }, to: -> to { to.even? }, for: 12.seconds
+        #   rule "Execute when item state is changed from an odd number, to an even number" do
+        #     changed Alarm_Mode, from: -> from { from.odd? }, to: -> to { to.even? }
         #     run { logger.info("Alarm Mode Updated") }
         #   end
         #
@@ -1057,6 +1107,22 @@ module OpenHAB
         #     run { logger.info("Alarm armed") }
         #   end
         #
+        # @example Delay the trigger until the item has been in the same state for 10 seconds
+        #    rule "Execute rule when item is changed for specified duration" do
+        #      changed Closet_Door, to: CLOSED, for: 10.seconds
+        #      run do
+        #        Closet_Light.off
+        #      end
+        #    end
+        #
+        # @example `for` parameter can be a proc that returns a duration:
+        #   Alarm_Delay << 20
+        #
+        #   rule "Execute rule when item is changed for specified duration" do
+        #     changed Alarm_Mode, for: -> { Alarm_Delay.state.to_i.seconds }
+        #     run { logger.info("Alarm Mode Updated") }
+        #   end
+        #
         # @example Works with Things:
         #   rule "Execute rule when thing is changed" do
         #     changed things["astro:sun:home"], :from => :online, :to => :uninitialized
@@ -1089,7 +1155,7 @@ module OpenHAB
               raise ArgumentError, "items must be an Item, GroupItem::Members, Thing, or ThingUID"
             end
 
-            logger.trace("Creating changed trigger for entity(#{item}), to(#{to.inspect}), from(#{from.inspect})")
+            logger.trace { "Creating changed trigger for entity(#{item}), to(#{to.inspect}), from(#{from.inspect})" }
 
             Array.wrap(from).each do |from_state|
               Array.wrap(to).each do |to_state|
@@ -1381,7 +1447,7 @@ module OpenHAB
           levels.each do |level|
             logger.warn "Rule engine doesn't start until start level 40" if level < 40
             config = { startlevel: level }
-            logger.trace("Creating a SystemStartlevelTrigger with startlevel=#{level}")
+            logger.trace { "Creating a SystemStartlevelTrigger with startlevel=#{level}" }
             Triggers::Trigger.new(rule_triggers: @rule_triggers)
                              .append_trigger(type: "core.SystemStartlevelTrigger", config: config, attach: attach)
           end
@@ -1480,7 +1546,7 @@ module OpenHAB
               raise ArgumentError, "items must be an Item or GroupItem::Members"
             end
             commands.each do |cmd|
-              logger.trace "Creating received command trigger for items #{item.inspect} and commands #{cmd.inspect}"
+              logger.trace { "Creating received command trigger for items #{item.inspect} and commands #{cmd.inspect}" }
 
               command_trigger.trigger(item: item, command: cmd, attach: attach)
             end
@@ -1699,7 +1765,7 @@ module OpenHAB
         #   end
         #
         def trigger(type, attach: nil, **configuration)
-          logger.trace("Creating trigger (#{type}) with configuration(#{configuration})")
+          logger.trace { "Creating trigger (#{type}) with configuration(#{configuration})" }
           Triggers::Trigger.new(rule_triggers: @rule_triggers)
                            .append_trigger(type: type, config: configuration, attach: attach)
         end
@@ -1802,13 +1868,48 @@ module OpenHAB
               raise ArgumentError, "items must be an Item, GroupItem::Members, Thing, or ThingUID"
             end
 
-            logger.trace("Creating updated trigger for item(#{item}) to(#{to})")
+            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)
             end
           end.flatten
         end
 
+        #
+        # Creates a time series updated trigger
+        #
+        # The `event` passed to run blocks will be a {OpenHAB::Core::Events::ItemTimeSeriesUpdatedEvent}
+        #
+        # @param [Item] items Items to create trigger for.
+        # @param [Object] attach Object to be attached to the trigger.
+        # @return [void]
+        #
+        # @since openHAB 4.1
+        # @see Core::Types::TimeSeries TimeSeries
+        # @see Core::Items::GenericItem#time_series= GenericItem#time_series=
+        #
+        # @example
+        #   rule 'Execute rule when item time series is updated' do
+        #     time_series_updated MyItem
+        #     run do |event|
+        #       logger.info("Item time series updated: #{event.item.name}.")
+        #       logger.info("  TimeSeries size: #{event.time_series.size}, policy: #{event.time_series.policy}")
+        #       event.time_series.each do |entry|
+        #         timestamp = entry.timestamp.to_time.strftime("%Y-%m-%d %H:%M:%S")
+        #         logger.info("    Entry: #{timestamp}: State: #{entry.state}")
+        #       end
+        #     end
+        #   end
+        #
+        def time_series_updated(*items, attach: nil)
+          @ruby_triggers << [:time_series_updated, items]
+          items.map do |item|
+            raise ArgumentError, "items must be an Item or GroupItem::Members" unless item.is_a?(Core::Items::Item)
+
+            event("openhab/items/#{item.name}/timeseriesupdated", types: "ItemTimeSeriesUpdatedEvent", attach: attach)
+          end
+        end
+
         #
         # Create a trigger to watch a path
         #
@@ -1987,7 +2088,7 @@ module OpenHAB
           elsif !execution_blocks?
             logger.warn "Rule '#{uid}' has no execution blocks, not creating rule"
           elsif !enabled
-            logger.trace "Rule '#{uid}' marked as disabled, not creating rule."
+            logger.trace { "Rule '#{uid}' marked as disabled, not creating rule." }
           else
             return true
           end
@@ -2024,7 +2125,7 @@ module OpenHAB
             duplicate_index += 1
             rule.uid = "#{base_uid} (#{duplicate_index})"
           end
-          logger.trace("Adding rule: #{rule}")
+          logger.trace { "Adding rule: #{rule}" }
           unmanaged_rule = Core.automation_manager.add_unmanaged_rule(rule)
           provider.add(unmanaged_rule)
           unmanaged_rule

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

@@ -26,8 +26,9 @@ module OpenHAB
         class << self
           # 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)
-            "#{file}:#{block.source_location.last}"
+            file = File.basename(block.source_location.first, ".rb")
+            file = "script:#{$ctx["ruleUID"]}" if $ctx&.key?("ruleUID") && file == "<script>"
+            "#{file}:#{block.source_location.last}".tr(".", "_")
           end
 
           # formulate a readable rule name such as "TestSwitch received command ON" if possible
@@ -47,8 +48,6 @@ module OpenHAB
             infer_rule_name_from_trigger(*config.ruby_triggers.first)
           end
 
-          private
-
           # formulate a readable rule name from a single trigger if possible
           def infer_rule_name_from_trigger(trigger, items = nil, kwargs = {})
             case trigger
@@ -64,11 +63,15 @@ module OpenHAB
               infer_rule_name_from_item_registry_trigger(trigger)
             when :thing_added, :thing_removed, :thing_updated
               infer_rule_name_from_thing_trigger(trigger)
+            when :time_series_updated
+              infer_rule_name_from_time_series_trigger(items)
             when :on_start
               infer_rule_name_from_on_start_trigger(items)
             end
           end
 
+          private
+
           # formulate a readable rule name from an item-type trigger
           def infer_rule_name_from_item_trigger(trigger, items, kwargs)
             kwargs.delete(:command) if kwargs[:command] == [nil]
@@ -83,10 +86,10 @@ module OpenHAB
 
             trigger_name = trigger.to_s.tr("_", " ")
             item_names = items.map do |item|
-              if item.is_a?(GroupItem::Members)
-                "#{item.group.name}.members"
-              else
-                item.name
+              case item
+              when GroupItem::Members then "#{item.group.name}.members"
+              when Core::Items::Item then item.name
+              else item.to_s
               end
             end
             name = "#{format_array(item_names)} #{trigger_name}"
@@ -136,6 +139,11 @@ module OpenHAB
             }[trigger]
           end
 
+          # formulate a readable rule name from a time series updated trigger
+          def infer_rule_name_from_time_series_trigger(items)
+            "#{format_array(items.map(&:name))} time series updated"
+          end
+
           # formulate a readable rule name from an on_start trigger
           def infer_rule_name_from_on_start_trigger(levels)
             levels = levels.map { |level| "#{level} (#{start_level_description(level)})" }

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

@@ -13,8 +13,10 @@ module OpenHAB
         # and a setter with any number of arguments or a block.
         #
         # @param [String] name of the property
+        # @yield Block to call when the property is set
+        # @yieldparam [Object] value the value being set
         #
-        def prop(name)
+        def prop(name, &assignment_block)
           # rubocop rules are disabled because this method is dynamically defined on the calling
           #   object making calls to other methods in this module impossible, or if done on methods
           #   in this module than instance variable belong to the module not the calling class
@@ -30,6 +32,7 @@ module OpenHAB
               elsif block
                 instance_variable_set(:"@#{name}", block)
               end
+              assignment_block&.call(instance_variable_get(:"@#{name}"))
             end
           end
         end

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

@@ -41,9 +41,9 @@ module OpenHAB
         #
         # @return [org.openhab.core.automation.Trigger] openHAB trigger
         #
-        def append_trigger(type:, config:, attach: nil, conditions: nil)
+        def append_trigger(type:, config:, attach: nil, conditions: nil, label: nil)
           config.transform_keys!(&:to_s)
-          RuleTriggers.trigger(type: type, config: config).tap do |trigger|
+          RuleTriggers.trigger(type: type, config: config, label: label).tap do |trigger|
             logger.trace("Appending trigger (#{trigger.inspect}) attach (#{attach}) conditions(#{conditions})")
             @triggers << trigger
             @attachments[trigger.id] = attach if attach
@@ -56,15 +56,17 @@ module OpenHAB
         #
         # @param [String] type of trigger
         # @param [Map] config map
+        # @param [String] label for the trigger
         #
         # @return [org.openhab.core.automation.Trigger] configured by type and supplied config
         #
-        def self.trigger(type:, config:)
+        def self.trigger(type:, config:, label: nil)
           logger.trace("Creating trigger of type '#{type}' config: #{config}")
           org.openhab.core.automation.util.TriggerBuilder.create
              .with_id(uuid)
              .with_type_uid(type)
              .with_configuration(Core::Configuration.new(config))
+             .with_label(label)
              .build
         end
 

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

@@ -20,29 +20,46 @@ module OpenHAB
         class << self
           # @!visibility private
           # @!macro def_terse_rule
-          #   @!method $1(*args, name :nil, id: nil, on_load: false, **kwargs, &block)
+          #   @!method $1(
+          #     *args,
+          #     id: nil,
+          #     name :nil,
+          #     description: nil,
+          #     tag: nil,
+          #     tags: nil,
+          #     on_load: false,
+          #     **kwargs,
+          #     &block)
           #   Create a new rule with a $1 trigger.
-          #   @param name [String] The name for the rule.
           #   @param id [String] The ID for the rule.
+          #   @param name [String] The name for the rule.
+          #   @param description [String, nil] The description for the rule.
+          #   @param tag [String, Symbol, Semantics::Tag, Array<String, Symbol, Semantics::Tag>, nil]
+          #     Tags to assign to the script
+          #   @param tags [String, Symbol, Semantics::Tag, Array<String, Symbol, Semantics::Tag>, nil]
+          #     Fluent alias for `tag`
           #   @param on_load [true, false] If the rule should _also_ trigger immediately when the script loads.
           #   @yield The execution block for the rule.
           #   @return [void]
           #   @see BuilderDSL#$1
           def def_terse_rule(trigger)
             class_eval(<<~RUBY, __FILE__, __LINE__ + 1)
-              def #{trigger}(*args, name: nil, id: nil, on_load: false, **kwargs, &block)     # def changed(*args, name: nil, id: nil, on_load: false, **kwargs, &block)
-                raise ArgumentError, "Block is required" unless block                         #   raise ArgumentError, "Block is required" unless block
-                                                                                              #
-                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
-                rule name, id: id, script: script, binding: caller_binding do                 #   rule name, id: id, script: script, binding: caller_binding do
-                  self.on_load if on_load                                                     #     self.on_load if on_load
-                  #{trigger}(*args, **kwargs)                                                 #     changed(*args, **kwargs)
-                  run(&block)                                                                 #     run(&block)
-                end                                                                           #   end
-              end                                                                             # end
-              module_function #{trigger.inspect}                                              # module_function :changed
+              def #{trigger}(*args, id: nil, name: nil, description: nil,       # def changed(*args, id: nil, name: nil, description: nil,
+                  tag: nil, tags: nil, on_load: false, **kwargs, &block)        #     tag: nil, tags: nil, on_load: false, **kwargs, &block)
+                raise ArgumentError, "Block is required" unless block           #   raise ArgumentError, "Block is required" unless block
+                                                                                #
+                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
+                rule name, id: id, script: script, binding: caller_binding do   #   rule name, id: id, script: script, binding: caller_binding do
+                  self.on_load if on_load                                       #     self.on_load if on_load
+                  self.description(description) if description                  #     self.description(description) if description
+                  self.tags(*Array.wrap(tag), *Array.wrap(tags))                #     self.tags(*Array.wrap(tag), *Array.wrap(tags))
+                  #{trigger}(*args, **kwargs)                                   #     changed(*args, **kwargs)
+                  run(&block)                                                   #     run(&block)
+                end                                                             #   end
+              end                                                               # end
+              module_function #{trigger.inspect}                                # module_function :changed
             RUBY
           end
         end

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

@@ -19,18 +19,26 @@ module OpenHAB
           # @param [Core::Items::Item, Core::Items::GroupItem::Members] item item to create trigger for
           # @param [Core::Types::State, Symbol, #===, nil] from state to restrict trigger to
           # @param [Core::Types::State, Symbol, #===, nil] to state to restrict trigger to
-          # @param [Duration, nil] duration duration to delay trigger until to state is met
+          # @param [Duration, Proc, nil] duration duration to delay trigger until to state is met
           # @param [Object] attach object to be attached to the trigger
           #
           # @return [org.openhab.core.automation.Trigger] openHAB triggers
           #
           def trigger(item:, from:, to:, duration:, attach:)
             if duration
-              item_name = item.respond_to?(:name) ? item.name : item.to_s
-              logger.trace("Creating Changed Wait Change Trigger for Item(#{item_name}) Duration(#{duration}) " \
-                           "To(#{to}) From(#{from}) Attach(#{attach})")
+              if logger.trace?
+                item_name = item.respond_to?(:name) ? item.name : item.to_s
+                logger.trace("Creating Changed Wait Change Trigger for Item(#{item_name}) Duration(#{duration}) " \
+                             "To(#{to}) From(#{from}) Attach(#{attach})")
+              end
               conditions = Conditions::Duration.new(to: to, from: from, duration: duration)
-              changed_trigger(item: item, from: nil, to: nil, attach: attach, conditions: conditions)
+              label = NameInference.infer_rule_name_from_trigger(:changed,
+                                                                 [item],
+                                                                 from: from,
+                                                                 to: to,
+                                                                 duration: duration)
+
+              changed_trigger(item: item, from: nil, to: nil, attach: attach, conditions: conditions, label: label)
             else
               # swap from/to w/ nil if from/to need to be processed in Ruby
               # rubocop:disable Style/ParallelAssignment
@@ -64,7 +72,7 @@ module OpenHAB
           # @param [Object] attach object to be attached to the trigger
           # @return [org.openhab.core.automation.Trigger]
           #
-          def changed_trigger(item:, from:, to:, attach: nil, conditions: nil)
+          def changed_trigger(item:, from:, to:, attach: nil, conditions: nil, label: nil)
             type, config = case item
                            when GroupItem::Members
                              group(group: item, from: from, to: to)
@@ -74,7 +82,7 @@ module OpenHAB
                            else
                              item(item: item, from: from, to: to)
                            end
-            append_trigger(type: type, config: config, attach: attach, conditions: conditions)
+            append_trigger(type: type, config: config, attach: attach, conditions: conditions, label: label)
           end
 
           #

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

@@ -12,7 +12,8 @@ module OpenHAB
         #
         class Cron < Trigger
           # Trigger ID for Cron Triggers
-          CRON_TRIGGER_MODULE_ID = if Gem::Version.new(OpenHAB::Core::VERSION) >= Gem::Version.new("4.0.0")
+          # @deprecated OH 3.4
+          CRON_TRIGGER_MODULE_ID = if OpenHAB::Core.version >= OpenHAB::Core::V4_0
                                      "timer.GenericCronTrigger"
                                    else
                                      # @deprecated OH3.4 We need to use a custom CronTrigger handler
@@ -211,7 +212,7 @@ module OpenHAB
           #
           def trigger(config:, attach:)
             # @deprecated OH3.4 needs a custom CronTriggerHandlerFactory
-            if Gem::Version.new(OpenHAB::Core::VERSION) < Gem::Version.new("4.0.0")
+            if OpenHAB::Core.version < OpenHAB::Core::V4_0
               CronHandler::CronTriggerHandlerFactory.instance # ensure it's registered
             end
             append_trigger(type: CRON_TRIGGER_MODULE_ID, config: config, attach: attach)