openhab-scripting 5.17.0 → 5.18.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ecc05f177e95b3a962f2b1fac6f924c5af5d6c49ed8a7e38d896c03417fe9e23
-  data.tar.gz: 408fa59899bb838caa9a6f3fc80ef82a4051c03fc590249ab53e0a098c5f335d
+  metadata.gz: cfc9ae60d0f82fc677a157ac0efd58c12fc597f5ac8f3d79d7aa9c472e2c5d3a
+  data.tar.gz: b8bf1721d064b2f88554722518496aa6c53b89407a9fb212880972725e49901f
 SHA512:
-  metadata.gz: ccbc0e426427d262cd1f2a5ed671979f5644b4c5b0da5ff34958254de6221283a9420e2b3c45384ac5aafc7feeffd41fa54740f76c4d99ccaa8adba207c32d52
-  data.tar.gz: 9f9a5f3b120a838f151a1f8edf5e1400f1df0a183cef5a47b921bc661889231c1b186ce2830f8cf7349ab3f89b166de5e1ffc89675628dba21799740b9029cc6
+  metadata.gz: 8e50f4ce2c5832a39b3ab9c7b7a489b22697a23b20ce803a633f28ea9b44ed2661a820cdefd00bc54c71cb212a2c1a1d96c35c413937cd3ac514aec55a4c13da
+  data.tar.gz: a298851e7255074cb21d9fd4e495a8c8dc750425b0db3319ab17353c2e07106e0f669a40912bbe98cc6db9f252ff70ebe68b9c94fb7366c4b257200da13eefda

data/lib/openhab/core/items/semantics/enumerable.rb

@@ -97,8 +97,8 @@ module Enumerable
   # Send a command to every item in the collection
   # @return [self, nil] nil when `ensure` is in effect and all the items were already in the same state,
   #   otherwise self
-  def command(command)
-    self if count { |i| i.command(command) }.positive?
+  def command(command, **kwargs)
+    self if count { |i| i.command(command, **kwargs) }.positive?
   end
 
   # Send a command to every item in the collection, even when {OpenHAB::DSL.ensure_states! ensure_states!} is in effect.

data/lib/openhab/core/rules/registry.rb

@@ -63,7 +63,8 @@ module OpenHAB
         #
         def remove(rule_uid)
           rule_uid = rule_uid.uid if rule_uid.is_a?(Rule)
-          provider = Provider.registry.provider_for(rule_uid)
+          return nil unless (provider = Provider.registry.provider_for(rule_uid))
+
           unless provider.is_a?(org.openhab.core.common.registry.ManagedProvider)
             raise "Cannot remove rule #{rule_uid} from non-managed provider #{provider.inspect}"
           end

data/lib/openhab/core/rules/rule.rb

@@ -149,6 +149,7 @@ module OpenHAB
           r += " #{visibility}" unless visible?
           r += " #{status || "<detached>"}"
           r += " (#{status_info.status_detail})" if status_info && status_info.status_detail != RuleStatusDetail::NONE
+          r += " description=#{description.inspect}" if description
           r += " tags=#{tags.to_a.inspect}" unless tags.empty?
           r += " configuration=#{configuration.properties.to_h}" if configuration && !configuration.properties.empty?
           "#{r}>"

data/lib/openhab/core/types/string_type.rb

@@ -26,7 +26,7 @@ module OpenHAB
         def eql?(other)
           return false unless other.instance_of?(self.class)
 
-          to_s.compare_to(other.to_s).zero?
+          to_s == other.to_s
         end
 
         #

data/lib/openhab/core/types/time_series.rb

@@ -101,12 +101,22 @@ module OpenHAB
         # @note This method returns self so it can be chained, unlike the Java version.
         #
         # @param [Instant, #to_zoned_date_time, #to_instant] instant An instant for the given state.
-        # @param [State] state The State at the given timestamp.
+        # @param [State, String, Numeric] state The State at the given timestamp.
+        #   If a String is given, it will be converted to {StringType}.
+        #   If a {Numeric} is given, it will be converted to {DecimalType}.
         # @return [self]
+        # @raise [ArgumentError] if state is not a {State}, String or {Numeric}
         #
         def add(instant, state)
           instant = instant.to_zoned_date_time if instant.respond_to?(:to_zoned_date_time)
           instant = instant.to_instant if instant.respond_to?(:to_instant)
+          state = case state
+                  when State then state
+                  when String then StringType.new(state)
+                  when Numeric then DecimalType.new(state)
+                  else
+                    raise ArgumentError, "state must be a State, String or Numeric, but was #{state.class}"
+                  end
           add_instant(instant, state)
           self
         end

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

@@ -672,7 +672,6 @@ module OpenHAB
         # @param (see ItemBuilder#initialize)
         def initialize(*args, type: nil, function: nil, thing: nil, **kwargs)
           raise ArgumentError, "invalid function #{function}" if function && !function.match?(FUNCTION_REGEX)
-          raise ArgumentError, "state cannot be set on GroupItems" if kwargs[:state]
 
           super(type, *args, **kwargs)
           @function = function

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

@@ -74,6 +74,7 @@ module OpenHAB
         end
 
         Core::Items::GenericItem.prepend(self)
+        Core::Items::GroupItem.prepend(self)
 
         #
         # Sends command to an item for specified duration, then on timer expiration sends

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: nil, 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)
+            elsif replace.nil?
+              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]
+        #
+        # @see DSL.rule
+        # @see DSL.scene!
         #
-        def scene(name = nil, description: nil, id: nil, tag: nil, tags: nil, script: nil, &block)
+        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

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
@@ -71,6 +70,8 @@ module OpenHAB
             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]
@@ -85,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}"

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

@@ -44,22 +44,27 @@ module OpenHAB
           #   @see BuilderDSL#$1
           def def_terse_rule(trigger)
             class_eval(<<~RUBY, __FILE__, __LINE__ + 1)
-              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
+              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
+                                                                           #
+                replace = nil                                              #   replace = nil
+                unless id                                                  #   unless id
+                  replace = false                                          #     replace = false
+                  id = NameInference.infer_rule_id_from_block(block)       #     id = NameInference.infer_rule_id_from_block(block)
+                end                                                        #   end
+                script = block.source rescue nil                           #   script = block.source rescue nil
+                caller_binding = block.binding                             #   caller_binding = block.binding
+                rule name, id: id, replace: replace, script: script,       #   rule name, id: id, replace: replace, script: script
+                  binding: caller_binding do                               #     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/watch/watch_handler.rb

@@ -301,7 +301,7 @@ module OpenHAB
               Core.automation_manager.add_trigger_type(org.openhab.core.automation.type.TriggerType.new(
                                                          WATCH_TRIGGER_MODULE_ID,
                                                          nil,
-                                                         "A path change event is detected",
+                                                         "a path change event is detected",
                                                          "Triggers when a path change event is detected",
                                                          nil,
                                                          org.openhab.core.automation.Visibility::VISIBLE,

data/lib/openhab/dsl/version.rb

@@ -4,6 +4,6 @@ module OpenHAB
   module DSL
     # Version of openHAB helper libraries
     # @return [String]
-    VERSION = "5.17.0"
+    VERSION = "5.18.1"
   end
 end

data/lib/openhab/dsl.rb

@@ -56,8 +56,14 @@ module OpenHAB
     # @!group Rule Creation
 
     # (see Rules::Builder#rule)
-    def rule(name = nil, **kwargs, &block)
-      rules.build { rule(name, **kwargs, &block) }
+    def rule(name = nil, id: nil, **kwargs, &block)
+      rules.build { rule(name, id: id, **kwargs, &block) }
+    end
+
+    # Creates a rule that will remove existing rules with the same id, even when the id has been inferred.
+    # @see rule
+    def rule!(name = nil, id: nil, **kwargs, &block)
+      rules.build { rule(name, id: id, replace: true, **kwargs, &block) }
     end
 
     # (see Rules::Builder#scene)
@@ -65,11 +71,27 @@ module OpenHAB
       rules.build { scene(name, description: description, id: id, tag: tag, tags: tags, **kwargs, &block) }
     end
 
+    # Creates a scene that will remove existing rules/scenes with the same id, even when the id has been inferred.
+    # @see scene
+    def scene!(name = nil, description: nil, id: nil, tag: nil, tags: nil, **kwargs, &block)
+      rules.build do
+        scene(name, description: description, id: id, tag: tag, tags: tags, replace: true, **kwargs, &block)
+      end
+    end
+
     # (see Rules::Builder#script)
     def script(name = nil, description: nil, id: nil, tag: nil, tags: nil, **kwargs, &block)
       rules.build { script(name, description: description, id: id, tag: tag, tags: tags, **kwargs, &block) }
     end
 
+    # Creates a script that will remove existing rules/scripts with the same id, even when the id has been inferred.
+    # @see script
+    def script!(name = nil, description: nil, id: nil, tag: nil, tags: nil, **kwargs, &block)
+      rules.build do
+        script(name, description: description, id: id, tag: tag, tags: tags, replace: true, **kwargs, &block)
+      end
+    end
+
     # @!group Rule Support
 
     # rubocop:disable Layout/LineLength

data/lib/openhab/rspec/mocks/persistence_service.rb

@@ -7,6 +7,15 @@ module OpenHAB
         include org.openhab.core.persistence.ModifiablePersistenceService
         include Singleton
 
+        OPERATOR_TO_SYMBOL = {
+          EQ: :==,
+          NEQ: :!=,
+          GT: :>,
+          LT: :<,
+          GTE: :>=,
+          LTE: :<=
+        }.freeze
+
         class HistoricItem
           include org.openhab.core.persistence.HistoricItem
 
@@ -134,9 +143,7 @@ module OpenHAB
 
           range = first_index...last_index
 
-          operator = filter.operator.symbol
-          operator = "==" if operator == "="
-
+          operator = OPERATOR_TO_SYMBOL[filter.operator]
           block = lambda do |i|
             next if filter.state && !item_history[i].state.send(operator, filter.state)
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: openhab-scripting
 version: !ruby/object:Gem::Version
-  version: 5.17.0
+  version: 5.18.1
 platform: ruby
 authors:
 - Brian O'Connell
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2024-01-30 00:00:00.000000000 Z
+date: 2024-04-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -485,7 +485,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.5
+rubygems_version: 3.5.7
 signing_key: 
 specification_version: 4
 summary: JRuby Helper Libraries for openHAB Scripting