openhab-scripting 5.6.0 → 5.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8c8baeb1d9f83c584fd3affe173ceecd5d00fedb8547701c134cc7f1e7e8b924
-  data.tar.gz: b202b62cba639b270e60a73c405b6de5ede001a8bd6ee4fa065363156497b396
+  metadata.gz: 86b3b636fb3b4c119d2ed6a5d6b81bedd731456c750d28f4e16f602d75778e7c
+  data.tar.gz: 673ed9dc1dfba2e38e1a57b01468c3a6d74a3a3fd0141c5bd9f51bc25d84e634
 SHA512:
-  metadata.gz: 06a58a345353b826ca398943d50295dd54a137b42d6fb803058507f6df19e673a27cacdfdaf7f7fa445d881468122535178e0a0f4f00eaa831ebe78bb4b060de
-  data.tar.gz: 5572ccf8e1e094d7b1eec9415e8d39b1f18b468e99d661b25f4064b1fde0d34a89d85163c4ce77b7f97b32f1532249d66cff310377e0850de0a1388f1e7f44a3
+  metadata.gz: 5974cf573c9fe03b1cd8df81cd312a6be70e3175c1a157d19db5dee17db2ecf8afae6619b5a3f81f91a2fce1834c7c24f7fbc7a6bf3166e60106050892d4f9ca
+  data.tar.gz: 9cced687ace50ae3bcab50ee9ad421e9bd34cabf5338b7d927c4415f540148bf2f8033f8e72b43814a0b8a94ad399b3119a3b3ea953a1215fbc8be3e915a77f5

data/lib/openhab/core/actions/audio.rb

@@ -23,8 +23,11 @@ module OpenHAB
           #
           def play_sound(filename, sink: nil, volume: nil)
             volume = PercentType.new(volume) unless volume.is_a?(PercentType) || volume.nil?
-            java_send :playSound, [java.lang.String, java.lang.String, PercentType.java_class],
-                      sink, filename.to_s, volume
+            java_send :playSound,
+                      [java.lang.String, java.lang.String, PercentType.java_class],
+                      sink,
+                      filename.to_s,
+                      volume
           end
 
           #

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

@@ -48,7 +48,7 @@ module OpenHAB
         # @yield Block executed in the context of a {DSL::Items::Builder}
         # @return [Object] The return value of the block.
         #
-        # (see Items::Builder)
+        # @see DSL::Items::Builder
         #
         def build(preferred_provider = nil, &block)
           DSL::Items::BaseBuilderDSL.new(preferred_provider).instance_eval_with_dummy_items(&block)

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

@@ -262,7 +262,7 @@ module OpenHAB
         # @deprecated OH3.4 cannot add a tag
         # this not in the class << self block above because YARD doesn't figure out
         # it's a class method with the conditional
-        if Provider.registry || org.openhab.core.semantics.SemanticTags.respond_to?(:add)
+        if Provider.registry
           class << self
             #
             # Adds custom semantic tags.
@@ -308,26 +308,19 @@ module OpenHAB
                 raise ArgumentError, "Additional options can only be specified when creating one tag"
               end
 
-              synonyms = Array.wrap(synonyms).map(&:to_s).map(&:strip)
+              synonyms = Array.wrap(synonyms).map { |s| s.to_s.strip }
 
               tags.map do |name, parent|
-                # @deprecated OH4.0.0.M4 missing registry
-                if Provider.registry
-                  parent = lookup(parent) unless parent.is_a?(SemanticTag)
-                  next if lookup(name)
-                  next unless parent
-
-                  new_tag = org.openhab.core.semantics.SemanticTagImpl.new("#{parent.uid}_#{name}", label, description,
-                                                                           synonyms)
-                  Provider.instance.add(new_tag)
-                  lookup(name)
-                else
-                  parent_is_tag = parent.respond_to?(:java_class) && parent.java_class < Tag.java_class
-                  parent = parent_is_tag ? parent.java_class : parent.to_s
-                  org.openhab.core.semantics.SemanticTags
-                     .add(name.to_s, parent, label, synonyms.join(","), description)
-                    &.then { lookup(name) }
-                end
+                parent = lookup(parent) unless parent.is_a?(SemanticTag)
+                next if lookup(name)
+                next unless parent
+
+                new_tag = org.openhab.core.semantics.SemanticTagImpl.new("#{parent.uid}_#{name}",
+                                                                         label,
+                                                                         description,
+                                                                         synonyms)
+                Provider.instance.add(new_tag)
+                lookup(name)
               end.compact
             end
           end

data/lib/openhab/core/provider.rb

@@ -44,6 +44,7 @@ module OpenHAB
 
       # Known supported provider types
       # @return [Array<Symbol>]
+      # @!visibility private
       KNOWN_TYPES = %i[items metadata things links].freeze
 
       class << self
@@ -223,7 +224,6 @@ module OpenHAB
       def initialize(unload_priority: nil)
         super()
         @elements = java.util.concurrent.ConcurrentHashMap.new
-        # @deprecated OH3.4 safe navigation only required for missing Semantics registry
         self.class.registry&.add_provider(self)
         ScriptHandling.script_unloaded(priority: unload_priority) { unregister }
       end

data/lib/openhab/core/sitemaps/provider.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+require "singleton"
+
+module OpenHAB
+  module Core
+    #
+    # Contains sitemap related classes.
+    #
+    module Sitemaps
+      #
+      # Provides sitemaps created in Ruby to openHAB
+      #
+      class Provider < Core::Provider
+        PREFIX = "jruby_"
+        SUFFIX = ".sitemap"
+        private_constant :PREFIX, :SUFFIX
+
+        class << self
+          # @!visibility private
+          def registry
+            nil
+          end
+        end
+
+        include org.openhab.core.model.sitemap.SitemapProvider
+
+        # @!visibility private
+        alias_method :getSitemap, :get
+
+        # rubocop:disable Naming/MethodName
+
+        # @!visibility private
+        def getSitemapNames
+          @elements.key_set
+        end
+
+        # @!visibility private
+        def addModelChangeListener(listener)
+          @listeners.add(listener)
+        end
+
+        # @!visibility private
+        def removeModelChangeListener(listener)
+          @listeners.remove(listener)
+        end
+
+        # rubocop:enable Naming/MethodName
+
+        # @!visibility private
+        def unregister
+          @registration.unregister
+        end
+
+        # rubocop:disable Layout/LineLength
+
+        #
+        # Enter the Sitemap Builder DSL.
+        #
+        # @yield Block executed in the context of a {DSL::Sitemaps::Builder}
+        # @return [void]
+        #
+        # @see DSL::Sitemaps::Builder
+        #
+        # @example
+        #   sitemaps.build do
+        #     sitemap "default", "My Residence" do
+        #       frame label: "Control" do
+        #         text label: "Climate", icon: "if:mdi:home-thermometer-outline" do
+        #           frame label: "Main Floor" do
+        #             text item: MainFloor_AmbTemp
+        #             switch item: MainFloorThermostat_TargetMode, label: "Mode", mappings: %w[off auto cool heat]
+        #             setpoint item: MainFloorThermostate_SetPoint, label: "Set Point", visibility: "MainFloorThermostat_TargetMode!=off"
+        #           end
+        #           frame label: "Basement" do
+        #             text item: Basement_AmbTemp
+        #             switch item: BasementThermostat_TargetMode, label: "Mode", mappings: { OFF: "off", COOL: "cool", HEAT: "heat" }
+        #             setpoint item: BasementThermostate_SetPoint, label: "Set Point", visibility: "BasementThermostat_TargetMode!=off"
+        #           end
+        #         end
+        #       end
+        #     end
+        #   end
+        #
+        def build(&block)
+          DSL::Sitemaps::Builder.new(self).instance_eval(&block)
+        end
+        # rubocop:enable Layout/LineLength
+
+        # For use in specs
+        # @!visibility private
+        def clear
+          elements = @elements
+          @elements = java.util.concurrent.ConcurrentHashMap.new
+          elements.each_value do |v|
+            notify_listeners_about_removed_element(v)
+          end
+        end
+
+        #
+        # Remove a sitemap.
+        #
+        # @param [String] sitemap_name
+        # @return [Boolean] If a sitemap was removed
+        def remove(sitemap_name)
+          super("#{PREFIX}#{sitemap_name}#{SUFFIX}")
+        end
+
+        private
+
+        def initialize
+          super
+          @listeners = java.util.concurrent.CopyOnWriteArraySet.new
+
+          @registration = OSGi.register_service(self, org.openhab.core.model.sitemap.SitemapProvider)
+        end
+
+        def notify_listeners_about_added_element(element)
+          @listeners.each { |l| l.model_changed(element.name, org.openhab.core.model.core.EventType::ADDED) }
+        end
+
+        def notify_listeners_about_removed_element(element)
+          @listeners.each { |l| l.model_changed(element.name, org.openhab.core.model.core.EventType::REMOVED) }
+        end
+
+        def notify_listeners_about_updated_element(element)
+          @listeners.each { |l| l.model_changed(element.name, org.openhab.core.model.core.EventType::MODIFIED) }
+        end
+      end
+    end
+  end
+end

data/lib/openhab/core/things/proxy.rb

@@ -13,7 +13,8 @@ module OpenHAB
         def_delegators :__getobj__, :class, :is_a?, :kind_of?
 
         # @!visibility private
-        EVENTS = [Events::ThingAddedEvent::TYPE, Events::ThingUpdatedEvent::TYPE,
+        EVENTS = [Events::ThingAddedEvent::TYPE,
+                  Events::ThingUpdatedEvent::TYPE,
                   Events::ThingRemovedEvent::TYPE].freeze
         # @!visibility private
         UID_METHOD = :uid

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

@@ -144,7 +144,8 @@ module OpenHAB
         def coerce(other)
           logger.trace("Coercing #{self} as a request from #{other.class}")
           return [other, zoned_date_time] if other.respond_to?(:to_zoned_date_time)
-          return [DateTimeType.new(other), self] if other.respond_to?(:to_time)
+
+          [DateTimeType.new(other), self] if other.respond_to?(:to_time)
         end
 
         #

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

@@ -28,7 +28,8 @@ module OpenHAB
         # @return [OpenClosedType] {OPEN} if {closed?}, {CLOSED} if {open?}
         def !
           return CLOSED if open?
-          return OPEN if closed?
+
+          OPEN if closed?
         end
       end
     end

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

@@ -174,25 +174,30 @@ module OpenHAB
           add: :+,
           subtract: :-
         }.each do |java_op, ruby_op|
-          convert = "self.class.new(other, DSL.unit(dimension) || unit)"
+          convert = "self.class.new(other, thread_unit)"
 
           class_eval( # rubocop:disable Style/DocumentDynamicEvalDefinition https://github.com/rubocop/rubocop/issues/10179
             # def +(other)
             #   logger.trace("#{self} + #{other} (#{other.class})")
             #   if other.is_a?(QuantityType)
             #     add_quantity(other)
-            #   elsif other.is_a?(DecimalType)
-            #     other = other.to_big_decimal
-            #     add_quantity(self.class.new(other, DSL.unit(dimension) || unit))
-            #   elsif other.is_a?(java.math.BigDecimal)
-            #     add_quantity(self.class.new(other, DSL.unit(dimension) || unit))
-            #   elsif other.respond_to?(:to_d)
-            #     other = other.to_d.to_java
-            #     add_quantity(self.class.new(other, DSL.unit(dimension) || unit))
-            #   elsif other.respond_to?(:coerce) && (lhs, rhs = other.coerce(to_d))
-            #     lhs + rhs
+            #   elsif (thread_unit = DSL.unit(dimension))
+            #     if other.is_a?(DecimalType)
+            #       other = other.to_big_decimal
+            #       add_quantity(self.class.new(other, thread_unit))
+            #     elsif other.is_a?(java.math.BigDecimal)
+            #       add_quantity(self.class.new(other, thread_unit))
+            #     elsif other.respond_to?(:to_d)
+            #       other = other.to_d.to_java
+            #       add_quantity(self.class.new(other, thread_unit))
+            #     elsif other.respond_to?(:coerce) && (lhs, rhs = other.coerce(to_d))
+            #       lhs + rhs
+            #     else
+            #       raise TypeError, "#{other.class} can't be coerced into #{self.class}"
+            #     end
             #   else
-            #     raise TypeError, "#{other.class} can't be coerced into #{self.class}"
+            #     raise TypeError,
+            #       "#{self.class} can only be added with another #{self.class} outside a unit block"
             #   end
             # end
             <<~RUBY, __FILE__, __LINE__ + 1
@@ -200,18 +205,23 @@ module OpenHAB
                 logger.trace("\#{self} #{ruby_op} \#{other} (\#{other.class})")
                 if other.is_a?(QuantityType)
                   #{java_op}_quantity(other)
-                elsif other.is_a?(DecimalType)
-                  other = other.to_big_decimal
-                  #{java_op}_quantity(#{convert})
-                elsif other.is_a?(java.math.BigDecimal)
-                  #{java_op}_quantity(#{convert})
-                elsif other.respond_to?(:to_d)
-                  other = other.to_d.to_java
-                  #{java_op}_quantity(#{convert})
-                elsif other.respond_to?(:coerce) && (lhs, rhs = other.coerce(to_d))
-                  lhs #{ruby_op} rhs
+                elsif (thread_unit = DSL.unit(dimension))
+                  if other.is_a?(DecimalType)
+                    other = other.to_big_decimal
+                    #{java_op}_quantity(#{convert})
+                  elsif other.is_a?(java.math.BigDecimal)
+                    #{java_op}_quantity(#{convert})
+                  elsif other.respond_to?(:to_d)
+                    other = other.to_d.to_java
+                    #{java_op}_quantity(#{convert})
+                  elsif other.respond_to?(:coerce) && (lhs, rhs = other.coerce(to_d))
+                    lhs #{ruby_op} rhs
+                  else
+                    raise TypeError, "\#{other.class} can't be coerced into \#{self.class}"
+                  end
                 else
-                  raise TypeError, "\#{other.class} can't be coerced into \#{self.class}"
+                  raise TypeError,
+                    "\#{self.class} can only be #{java_op}ed with another \#{self.class} outside a unit block"
                 end
               end
             RUBY
@@ -243,13 +253,13 @@ module OpenHAB
               def #{ruby_op}(other)
                 logger.trace("\#{self} #{ruby_op} \#{other} (\#{other.class})")
                 if other.is_a?(QuantityType)
-                  #{java_op}_quantity(other)
+                  #{java_op}_quantity(other).unitize
                 elsif other.is_a?(DecimalType)
-                  #{java_op}(other.to_big_decimal)
+                  #{java_op}(other.to_big_decimal).unitize
                 elsif other.is_a?(java.math.BigDecimal)
-                  #{java_op}(other)
+                  #{java_op}(other).unitize
                 elsif other.respond_to?(:to_d)
-                  #{java_op}(other.to_d.to_java)
+                  #{java_op}(other.to_d.to_java).unitize
                 elsif other.respond_to?(:coerce) && (lhs, rhs = other.coerce(to_d))
                   lhs #{ruby_op} rhs
                 else
@@ -262,7 +272,7 @@ module OpenHAB
 
         # if it's a dimensionless quantity, change the unit to match other_unit
         # @!visibility private
-        def unitize(other_unit = unit)
+        def unitize(other_unit = unit, relative: false)
           # prefer converting to the thread-specified unit if there is one
           other_unit = DSL.unit(dimension) || other_unit
           logger.trace("Converting #{self} to #{other_unit}")
@@ -273,7 +283,7 @@ module OpenHAB
           when other_unit
             self
           else
-            to_unit(other_unit)
+            relative ? to_unit_relative(other_unit) : to_unit(other_unit)
           end
         end
 
@@ -288,16 +298,16 @@ module OpenHAB
 
         private
 
-        # do addition directly against a QuantityType while ensuring we unitize
-        # both sides
+        # do addition directly against a QuantityType while ensuring we unitize both sides
         def add_quantity(other)
-          unitize(other.unit).add(other.unitize(unit))
+          self_unit = (unit == Units::ONE && DSL.unit(other.dimension)) || unit
+          unitize(self_unit).add(other.unitize(relative: true))
         end
 
-        # do subtraction directly against a QuantityType while ensuring we
-        # unitize both sides
+        # do subtraction directly against a QuantityType while ensuring we unitize both sides
         def subtract_quantity(other)
-          unitize(other.unit).subtract(other.unitize(unit))
+          self_unit = (unit == Units::ONE && DSL.unit(other.dimension)) || unit
+          unitize(self_unit).subtract(other.unitize(relative: true))
         end
 
         # do multiplication directly against a QuantityType while ensuring

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

@@ -63,7 +63,7 @@ module OpenHAB
         #
         def coerce(other)
           logger.trace("Coercing #{self} as a request from #{other.class}")
-          return [other.to_str, self] if other.respond_to?(:to_str)
+          [other.to_str, self] if other.respond_to?(:to_str)
         end
 
         # any method that exists on String gets forwarded to to_s

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

@@ -37,7 +37,8 @@ module OpenHAB
         #
         def !
           return UP if down?
-          return DOWN if up?
+
+          DOWN if up?
         end
       end
     end

data/lib/openhab/core/value_cache.rb

@@ -107,10 +107,11 @@ module OpenHAB
 
       # @see https://docs.ruby-lang.org/en/master/Hash.html#method-i-assoc Hash#assoc
       def assoc(key)
-        [key, fetch(key) do
-          # return nil directly, without storing a value to the cache
-          return nil
-        end]
+        [key,
+         fetch(key) do
+           # return nil directly, without storing a value to the cache
+           return nil
+         end]
       end
 
       # @see https://docs.ruby-lang.org/en/master/Hash.html#method-i-dig Hash#dig

data/lib/openhab/core_ext/java/duration.rb

@@ -64,7 +64,8 @@ module OpenHAB
         #
         def coerce(other)
           return [other.seconds, self] if other.is_a?(Numeric)
-          return [other.to_i.seconds, self] if other.is_a?(Period)
+
+          [other.to_i.seconds, self] if other.is_a?(Period)
         end
 
         {

data/lib/openhab/core_ext/java/local_time.rb

@@ -56,12 +56,14 @@ module OpenHAB
             return raw_parse(string, formatter) if formatter
 
             format = /(am|pm)$/i.match?(string) ? "h[:mm[:ss][.S]][ ]a" : "H[:mm[:ss][.S]]"
-            java_send(:parse, [java.lang.CharSequence, java.time.format.DateTimeFormatter],
-                      string, java.time.format.DateTimeFormatterBuilder.new
-                              .parse_case_insensitive
-                              .parse_lenient
-                              .append_pattern(format)
-                              .to_formatter(java.util.Locale::ENGLISH))
+            java_send(:parse,
+                      [java.lang.CharSequence, java.time.format.DateTimeFormatter],
+                      string,
+                      java.time.format.DateTimeFormatterBuilder.new
+                                                               .parse_case_insensitive
+                                                               .parse_lenient
+                                                               .append_pattern(format)
+                                                               .to_formatter(java.util.Locale::ENGLISH))
           end
         end
 

data/lib/openhab/core_ext/java/month_day.rb

@@ -21,7 +21,8 @@ module OpenHAB
           #
           def parse(string)
             logger.trace("#{self.class}.parse #{string} (#{string.class})")
-            java_send(:parse, [java.lang.CharSequence, java.time.format.DateTimeFormatter],
+            java_send(:parse,
+                      [java.lang.CharSequence, java.time.format.DateTimeFormatter],
                       string.to_s,
                       java.time.format.DateTimeFormatter.ofPattern("[--]M-d"))
           end

data/lib/openhab/core_ext/java/period.rb

@@ -47,7 +47,7 @@ module OpenHAB
         # @return [Array, nil]
         #
         def coerce(other)
-          return [other.seconds, to_i.seconds] if other.is_a?(Numeric)
+          [other.seconds, to_i.seconds] if other.is_a?(Numeric)
         end
 
         {

data/lib/openhab/core_ext/ruby/numeric.rb

@@ -190,6 +190,7 @@ module OpenHAB
       # Integer already has #|, so we have to prepend it here
       ::Integer.prepend(QuantityTypeConversion)
       ::Numeric.include(Numeric)
+      java.math.BigDecimal.include(QuantityTypeConversion)
     end
   end
 end

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

@@ -270,7 +270,9 @@ module OpenHAB
         #   Homekit metadata (see {ItemBuilder#homekit})
         # @param metadata [Hash<String, Hash>] Generic metadata (see {ItemBuilder#metadata})
         # @param state [State] Initial state
-        def initialize(type, name = nil, label = nil,
+        def initialize(type,
+                       name = nil,
+                       label = nil,
                        provider:,
                        dimension: nil,
                        unit: nil,

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

@@ -70,7 +70,8 @@ module OpenHAB
             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,
+            builder.guard = Guard.new(run_context: builder.caller,
+                                      only_if: builder.only_if,
                                       not_if: builder.not_if)
 
             name ||= NameInference.infer_rule_name(builder)
@@ -1075,28 +1076,50 @@ module OpenHAB
         #
         # @overload cron(second: nil, minute: nil, hour: nil, dom: nil, month: nil, dow: nil, year: nil, attach: nil)
         #   The trigger can be created by specifying each field as keyword arguments.
-        #   Omitted fields will default to `*` or `?` as appropriate.
+        #
+        #   When certain fields were omitted:
+        #     - The more specific fields will default to `0` for `hour`, `minute`, and `second`,
+        #       to `MON` for `dow`, and to `1` for `dom` and `month`.
+        #     - The less specific fields will default to `*` or `?` as appropriate.
         #
         #   Each field is optional, but at least one must be specified.
         #
         #   The same rules for the standard
         #   [cron expression](https://www.quartz-scheduler.org/documentation/quartz-2.2.2/tutorials/tutorial-lesson-06.html)
         #   apply for each field. For example, multiple values can be separated
-        #   with a comma within a string.
-        #
-        #   @param [Integer, String, nil] second
-        #   @param [Integer, String, nil] minute
-        #   @param [Integer, String, nil] hour
-        #   @param [Integer, String, nil] dom
-        #   @param [Integer, String, nil] month
-        #   @param [Integer, String, nil] dow
-        #   @param [Integer, String, nil] year
+        #   with a comma within a string, and ranges can be specified with a dash or with
+        #   a Ruby Range.
+        #
+        #   @param [Integer, String, Range, nil] second
+        #   @param [Integer, String, Range, nil] minute
+        #   @param [Integer, String, Range, nil] hour
+        #   @param [Integer, String, Symbol, Range, nil] dom
+        #   @param [Integer, String, Symbol, Range, nil] month
+        #   @param [Integer, String, Symbol, Range, nil] dow
+        #   @param [Integer, String, Range, nil] year
         #   @param [Object] attach object to be attached to the trigger
-        #   @example
+        #
+        #   @example Using String values
         #     # Run every 3 minutes on Monday to Friday
         #     # equivalent to the cron expression "0 */3 * ? * MON-FRI *"
         #     rule "Using cron fields" do
-        #       cron second: 0, minute: "*/3", dow: "MON-FRI"
+        #       cron minute: "*/3", dow: "MON-FRI"
+        #       run { logger.info "Cron rule executed" }
+        #     end
+        #
+        #   @example Defaults for unspecified fields
+        #     # Run at midnight on the first day of January, February, and March
+        #     # equivalent to the cron expression "0 0 0 1 JAN-MAR ? *"
+        #     rule "Using cron fields" do
+        #       cron month: "JAN-MAR"
+        #       run { logger.info "Cron rule executed" }
+        #     end
+        #
+        #   @example Using Ruby Range values
+        #     # Run on the hour, every hour between 1pm and 5pm
+        #     # equivalent to the cron expression "0 0 13-17 ? * ? *"
+        #     rule "Using cron fields" do
+        #       cron hour: 13..17
         #       run { logger.info "Cron rule executed" }
         #     end
         #
@@ -1559,18 +1582,25 @@ module OpenHAB
           # @deprecated OH3.4 - OH3 config uses eventXXX vs OH4 uses `topic`, `source`, and `types`
           # See https://github.com/openhab/openhab-core/pull/3299
           trigger("core.GenericEventTrigger",
-                  eventTopic: topic, eventSource: source, eventTypes: types, # @deprecated OH3.4
-                  topic: topic, source: source, types: types,
+                  eventTopic: topic,
+                  eventSource: source,
+                  eventTypes: types, # @deprecated OH3.4
+                  topic: topic,
+                  source: source,
+                  types: types,
                   attach: attach)
         end
 
         #
-        # Creates a trigger based on the time stored in a {DateTimeItem}
+        # Creates a trigger based on the date and time stored in a {DateTimeItem}
+        #
+        # The trigger will dynamically update whenever the state of the item changes.
+        # If the item is {NULL} or {UNDEF}, the trigger will not run.
         #
-        # The trigger will dynamically update any time the state of the item
-        # changes. If the item is {NULL} or {UNDEF}, the trigger will not run.
+        # To trigger just on the time portion of the item, use {every} instead, e.g.
+        # `every :day, at: MyDateTimeItem`.
         #
-        # @param [Item, String, Symbol] item The item (or it's name)
+        # @param [Item, String, Symbol] item The item (or its name)
         # @return [void]
         #
         # @example
@@ -1831,10 +1861,11 @@ module OpenHAB
           types = [binding.local_variable_get(:for)].flatten
 
           WatchHandler::WatchTriggerHandlerFactory.instance # ensure it's registered
-          trigger(WatchHandler::WATCH_TRIGGER_MODULE_ID, path: path.to_s,
-                                                         types: types.map(&:to_s),
-                                                         glob: glob.to_s,
-                                                         attach: attach)
+          trigger(WatchHandler::WATCH_TRIGGER_MODULE_ID,
+                  path: path.to_s,
+                  types: types.map(&:to_s),
+                  glob: glob.to_s,
+                  attach: attach)
         end
 
         # @!endgroup

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

@@ -29,7 +29,7 @@ module OpenHAB
             # @param [Hash] inputs inputs from trigger
             # @return [true, false] if the conditions passed (and therefore the block was run)
             #
-            def process(mod:, inputs:) # rubocop:disable Lint/UnusedMethodArgument - mod is unused here but required
+            def process(mod:, inputs:)
               logger.trace("Checking #{inputs} against condition trigger #{self}")
               unless check_value(Conditions.old_state_from(inputs), @from) &&
                      check_value(Conditions.new_state_from(inputs), @to) &&