openhab-scripting 5.35.1 → 5.36.0

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

@@ -96,7 +96,7 @@ module OpenHAB
         # @yieldparam [GroupItemBuilder] builder Item for further customization
         # @return [GroupItem]
         def group_item(*args, **kwargs, &block)
-          item = GroupItemBuilder.new(*args, provider: provider, **kwargs)
+          item = GroupItemBuilder.new(*args, provider:, **kwargs)
           item.instance_eval(&block) if block
           result = provider.add(item)
           item.members.each do |i|
@@ -108,7 +108,7 @@ module OpenHAB
         private
 
         def item(*args, **kwargs, &block)
-          item = ItemBuilder.new(*args, provider: provider, **kwargs)
+          item = ItemBuilder.new(*args, provider:, **kwargs)
           item.instance_eval(&block) if block
           r = provider.add(item)
           return Core::Items::Proxy.new(r) if r.is_a?(Item)
@@ -189,7 +189,7 @@ module OpenHAB
         attr_reader :provider
 
         def initialize(provider, update:)
-          @provider = ProviderWrapper.new(Core::Items::Provider.current(provider), update: update)
+          @provider = ProviderWrapper.new(Core::Items::Provider.current(provider), update:)
         end
       end
 
@@ -216,9 +216,6 @@ module OpenHAB
         attr_accessor :dimension
         # Unit (for number items only)
         #
-        # Due to {format} inference, setting the unit is cross-compatible with
-        # openHAB 3.4 and 4.0.
-        #
         # @return [String, nil]
         attr_reader :unit
         # The formatting pattern for the item's state
@@ -294,15 +291,10 @@ module OpenHAB
           #
           # @!visibility private
           def normalize_tags(*tags)
-            # @deprecated OH3.4 didn't have SemanticTag
-            old_semantics = proc { |tag| tag.is_a?(Module) && tag < Semantics::Tag }
-            # @deprecated OH3.4 defined? check is unnecessary
-            semantics = proc { |tag| defined?(Semantics::SemanticTag) && tag.is_a?(Semantics::SemanticTag) }
-
             tags.compact.map do |tag|
               case tag
               when String then tag
-              when Symbol, semantics, old_semantics then tag.to_s
+              when Symbol, Semantics::SemanticTag then tag.to_s
               else raise ArgumentError, "`#{tag}` must be a subclass of Semantics::Tag, a `Symbol`, or a `String`."
               end
             end
@@ -793,7 +785,7 @@ module OpenHAB
           RUBY
         end
 
-        FUNCTION_REGEX = /^([a-z]+)(?:\((.*)\))?/i.freeze
+        FUNCTION_REGEX = /^([a-z]+)(?:\((.*)\))?/i
         private_constant :FUNCTION_REGEX
 
         # The combiner function for this group

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

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require "ruby2_keywords"
-
 module OpenHAB
   module DSL
     module Items
@@ -29,7 +27,7 @@ module OpenHAB
         module Item
           include Ensurable
 
-          Core::Items::GenericItem.prepend(self)
+          Core::Items::Item.prepend(self)
 
           # If `ensure_states` is active (by block or chained method), then
           # check if this item is in the command's state before actually
@@ -85,11 +83,11 @@ module OpenHAB
           end
 
           # activate `ensure_states` before forwarding to the wrapped object
-          ruby2_keywords def method_missing(method, *args, &block)
+          def method_missing(method, ...)
             return super unless @item.respond_to?(method)
 
             DSL.ensure_states do
-              @item.__send__(method, *args, &block)
+              @item.__send__(method, ...)
             end
           end
 

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

@@ -100,7 +100,7 @@ module OpenHAB
           attr_reader :timed_commands
         end
 
-        Core::Items::GenericItem.prepend(self)
+        Core::Items::Item.prepend(self)
         Core::Items::GroupItem.prepend(self)
 
         #
@@ -159,11 +159,11 @@ module OpenHAB
             on_expire ||= default_on_expire(command)
             if only_when_ensured
               DSL.ensure_states do
-                create_timed_command(command, duration: duration, on_expire: on_expire) if super(command, **kwargs)
+                create_timed_command(command, duration:, on_expire:) if super(command, **kwargs)
               end
             else
               super(command, **kwargs)
-              create_timed_command(command, duration: duration, on_expire: on_expire)
+              create_timed_command(command, duration:, on_expire:)
             end
           end
 
@@ -201,7 +201,7 @@ module OpenHAB
         # Creates a new timed command and places it in the TimedCommand hash
         def create_timed_command(command, duration:, on_expire:)
           timed_command_details = TimedCommandDetails.new(item: self,
-                                                          on_expire: on_expire,
+                                                          on_expire:,
                                                           mutex: Mutex.new)
 
           timed_command_details.timer = timed_command_timer(timed_command_details, duration)

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

@@ -9,7 +9,7 @@ module OpenHAB
       # @!visibility private
       class AutomationRule < org.openhab.core.automation.module.script.rulesupport.shared.simple.SimpleRule
         # @!visibility private
-        INPUT_KEY_PATTERN = /^[a-z_]+[a-zA-Z0-9_]*$/.freeze
+        INPUT_KEY_PATTERN = /^[a-z_]+[a-zA-Z0-9_]*$/
 
         class << self
           #
@@ -83,7 +83,7 @@ module OpenHAB
               logger.trace("Execute called with mod (#{mod&.to_string}) and inputs (#{inputs.inspect})")
               logger.trace("Event details #{inputs["event"].inspect}") if inputs&.key?("event")
             end
-            trigger_conditions(inputs).process(mod: mod, inputs: inputs) do
+            trigger_conditions(inputs).process(mod:, inputs:) do
               event = extract_event(inputs)
               @debouncer.call { process_queue(create_queue(event), mod, event) }
             end
@@ -120,7 +120,7 @@ module OpenHAB
         # @return [Queue] <description>
         #
         def create_queue(event)
-          case check_guards(event: event)
+          case check_guards(event:)
           when true
             @run_queue.dup.grep_v(BuilderDSL::Otherwise)
           when false

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

@@ -7,7 +7,7 @@ require_relative "guard"
 require_relative "rule_triggers"
 require_relative "terse"
 
-Dir[File.expand_path("triggers/*.rb", __dir__)].sort.each do |f|
+Dir[File.expand_path("triggers/*.rb", __dir__)].each do |f|
   require f
 end
 
@@ -76,7 +76,6 @@ module OpenHAB
         def rule(name = nil, id: nil, replace: nil, script: nil, binding: nil, &block)
           raise ArgumentError, "Block is required" unless block
 
-          inferred_id = nil
           id ||= inferred_id = NameInference.infer_rule_id_from_block(block)
           script ||= block.source rescue nil # rubocop:disable Style/RescueModifier
 
@@ -158,7 +157,7 @@ module OpenHAB
         def script(name = nil, description: nil, id: nil, tag: nil, tags: nil, replace: false, script: nil, &block)
           raise ArgumentError, "Block is required" unless block
 
-          inferred_id = nil # rubocop:disable Lint/UselessAssignment it is used below
+          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
@@ -749,7 +748,7 @@ module OpenHAB
         #
         def debounce_for(debounce_time)
           idle_time = debounce_time.is_a?(Range) ? debounce_time.begin : debounce_time
-          debounce(for: debounce_time, idle_time: idle_time)
+          debounce(for: debounce_time, idle_time:)
         end
         # rubocop:enable Layout/LineLength
 
@@ -981,12 +980,12 @@ module OpenHAB
         #
         def channel(*channels, thing: nil, triggered: nil, attach: nil)
           channel_trigger = Channel.new(rule_triggers: @rule_triggers)
-          flattened_channels = Channel.channels(channels: channels, thing: thing)
+          flattened_channels = Channel.channels(channels:, thing:)
           triggers = [triggered].flatten
-          @ruby_triggers << [:channel, flattened_channels, { triggers: triggers }]
+          @ruby_triggers << [:channel, flattened_channels, { triggers: }]
           flattened_channels.each do |channel|
             triggers.each do |trigger|
-              channel_trigger.trigger(channel: channel, trigger: trigger, attach: attach)
+              channel_trigger.trigger(channel:, trigger:, attach:)
             end
           end
         end
@@ -1014,7 +1013,7 @@ module OpenHAB
         def channel_linked(item: nil, channel: nil, attach: nil)
           pattern = (item.nil? && channel.nil?) ? "*" : "#{item || "*"}-#{channel || "*"}"
           @ruby_triggers << [:channel_linked, pattern]
-          event("openhab/links/#{pattern}/added", types: "ItemChannelLinkAddedEvent", attach: attach)
+          event("openhab/links/#{pattern}/added", types: "ItemChannelLinkAddedEvent", attach:)
         end
 
         #
@@ -1043,7 +1042,7 @@ module OpenHAB
         def channel_unlinked(item: nil, channel: nil, attach: nil)
           pattern = (item.nil? && channel.nil?) ? "*" : "#{item || "*"}-#{channel || "*"}"
           @ruby_triggers << [:channel_unlinked, pattern]
-          event("openhab/links/#{pattern}/removed", types: "ItemChannelLinkRemovedEvent", attach: attach)
+          event("openhab/links/#{pattern}/removed", types: "ItemChannelLinkRemovedEvent", attach:)
         end
 
         #
@@ -1166,7 +1165,7 @@ module OpenHAB
           # for is a reserved word in ruby, so use local_variable_get :for
           duration = binding.local_variable_get(:for)
 
-          @ruby_triggers << [:changed, items, { to: to, from: from, duration: duration }]
+          @ruby_triggers << [:changed, items, { to:, from:, duration: }]
 
           from = [nil] if from.nil?
           to = [nil] if to.nil?
@@ -1187,7 +1186,7 @@ module OpenHAB
 
             Array.wrap(from).each do |from_state|
               Array.wrap(to).each do |to_state|
-                changed.trigger(item: item, from: from_state, to: to_state, duration: duration, attach: attach)
+                changed.trigger(item:, from: from_state, to: to_state, duration:, attach:)
               end
             end
           end
@@ -1264,13 +1263,13 @@ module OpenHAB
             raise ArgumentError, "Cron elements cannot be used with a cron expression" if expression
 
             cron_expression = Cron.from_fields(fields)
-            return cron(cron_expression, attach: attach)
+            return cron(cron_expression, attach:)
           end
 
           raise ArgumentError, "Missing cron expression or elements" unless expression
 
           cron = Cron.new(rule_triggers: @rule_triggers)
-          cron.trigger(config: { "cronExpression" => expression }, attach: attach)
+          cron.trigger(config: { "cronExpression" => expression }, attach:)
         end
 
         #
@@ -1387,8 +1386,8 @@ module OpenHAB
           raise ArgumentError, "Offset can only be used when 'at' is given a DateTimeItem" if offset && !at.is_a?(Item)
 
           if Cron.all_dow_symbols?(values)
-            @ruby_triggers << [:every, values.join(", "), { at: at }]
-            return cron(Cron.from_dow_symbols(values, at), attach: attach)
+            @ruby_triggers << [:every, values.join(", "), { at: }]
+            return cron(Cron.from_dow_symbols(values, at), attach:)
           end
 
           if values.size != 1
@@ -1400,18 +1399,13 @@ module OpenHAB
           value = values.first
           value = java.time.MonthDay.parse(value.to_str) if value.respond_to?(:to_str)
 
-          @ruby_triggers << [:every, value, { at: at }]
+          @ruby_triggers << [:every, value, { at: }]
 
           if value == :day && at.is_a?(Item)
-            # @deprecated OH 3.4 - attachments are supported in OH 4.0+
-            if Core.version <= Core::V4_0 && !attach.nil?
-              raise ArgumentError, "Attachments are not supported with dynamic datetime triggers in openHAB 3.x"
-            end
-
             offset ||= 0
             offset = offset.to_i # Duration#to_i converts it to seconds, but we also want to convert float/string to int
             @ruby_triggers.last[2][:offset] = offset
-            return trigger("timer.DateTimeTrigger", itemName: at.name, timeOnly: true, offset: offset, attach: attach)
+            return trigger("timer.DateTimeTrigger", itemName: at.name, timeOnly: true, offset:, attach:)
           end
 
           cron_expression = case value
@@ -1420,7 +1414,7 @@ module OpenHAB
                             when java.time.MonthDay then Cron.from_monthday(value, at)
                             else raise ArgumentError, "Unknown interval"
                             end
-          cron(cron_expression, attach: attach)
+          cron(cron_expression, attach:)
         end
 
         #
@@ -1453,7 +1447,7 @@ module OpenHAB
           # prevent overwriting @on_load
           raise ArgumentError, "on_load can only be used once within a rule" if @on_load
 
-          @on_load = { module: SecureRandom.uuid, delay: delay }
+          @on_load = { module: SecureRandom.uuid, delay: }
           attachments[@on_load[:module]] = attach
         end
 
@@ -1525,7 +1519,7 @@ module OpenHAB
             config = { 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)
+                             .append_trigger(type: "core.SystemStartlevelTrigger", config:, attach:)
           end
         end
 
@@ -1624,7 +1618,7 @@ module OpenHAB
             commands.each do |cmd|
               logger.trace { "Creating received command trigger for items #{item.inspect} and commands #{cmd.inspect}" }
 
-              command_trigger.trigger(item: item, command: cmd, attach: attach)
+              command_trigger.trigger(item:, command: cmd, attach:)
             end
           end
         end
@@ -1649,7 +1643,7 @@ module OpenHAB
         #    end
         def item_added(pattern = "*", attach: nil)
           @ruby_triggers << [:item_added, pattern]
-          event("openhab/items/#{pattern}/added", types: "ItemAddedEvent", attach: attach)
+          event("openhab/items/#{pattern}/added", types: "ItemAddedEvent", attach:)
         end
 
         #
@@ -1672,7 +1666,7 @@ module OpenHAB
         #    end
         def item_removed(pattern = "*", attach: nil)
           @ruby_triggers << [:item_removed, pattern]
-          event("openhab/items/#{pattern}/removed", types: "ItemRemovedEvent", attach: attach)
+          event("openhab/items/#{pattern}/removed", types: "ItemRemovedEvent", attach:)
         end
 
         #
@@ -1694,7 +1688,7 @@ module OpenHAB
         #
         def item_updated(pattern = "*", attach: nil)
           @ruby_triggers << [:item_updated, pattern]
-          event("openhab/items/#{pattern}/updated", types: "ItemUpdatedEvent", attach: attach)
+          event("openhab/items/#{pattern}/updated", types: "ItemUpdatedEvent", attach:)
         end
 
         #
@@ -1717,7 +1711,7 @@ module OpenHAB
         #    end
         def thing_added(pattern = "*", attach: nil)
           @ruby_triggers << [:thing_added, pattern]
-          event("openhab/things/#{pattern}/added", types: "ThingAddedEvent", attach: attach)
+          event("openhab/things/#{pattern}/added", types: "ThingAddedEvent", attach:)
         end
 
         #
@@ -1740,7 +1734,7 @@ module OpenHAB
         #    end
         def thing_removed(pattern = "*", attach: nil)
           @ruby_triggers << [:thing_removed, pattern]
-          event("openhab/things/#{pattern}/removed", types: "ThingRemovedEvent", attach: attach)
+          event("openhab/things/#{pattern}/removed", types: "ThingRemovedEvent", attach:)
         end
 
         #
@@ -1764,7 +1758,7 @@ module OpenHAB
         #
         def thing_updated(pattern = "*", attach: nil)
           @ruby_triggers << [:thing_updated, pattern]
-          event("openhab/things/#{pattern}/updated", types: "ThingUpdatedEvent", attach: attach)
+          event("openhab/things/#{pattern}/updated", types: "ThingUpdatedEvent", attach:)
         end
 
         #
@@ -1787,16 +1781,11 @@ module OpenHAB
         #
         def event(topic, source: nil, types: nil, attach: nil)
           types = types.join(",") if types.is_a?(Enumerable)
-          # @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,
-                  attach: attach)
+                  topic:,
+                  source:,
+                  types:,
+                  attach:)
         end
 
         #
@@ -1845,8 +1834,8 @@ module OpenHAB
           item = item.name if item.is_a?(Item)
           offset ||= 0
           offset = offset.to_i if offset.is_a?(Duration)
-          @ruby_triggers << [:at, item, { offset: offset }]
-          trigger("timer.DateTimeTrigger", itemName: item.to_s, offset: offset)
+          @ruby_triggers << [:at, item, { offset: }]
+          trigger("timer.DateTimeTrigger", itemName: item.to_s, offset:)
         end
 
         #
@@ -1888,7 +1877,7 @@ module OpenHAB
         def trigger(type, attach: nil, **configuration)
           logger.trace { "Creating trigger (#{type}) with configuration(#{configuration})" }
           Triggers::Trigger.new(rule_triggers: @rule_triggers)
-                           .append_trigger(type: type, config: configuration, attach: attach)
+                           .append_trigger(type:, config: configuration, attach:)
         end
 
         #
@@ -1977,7 +1966,7 @@ module OpenHAB
         #
         def updated(*items, to: nil, attach: nil)
           updated = Updated.new(rule_triggers: @rule_triggers)
-          @ruby_triggers << [:updated, items, { to: to }]
+          @ruby_triggers << [:updated, items, { to: }]
           items.map do |item|
             case item
             when Core::Things::Thing,
@@ -1991,7 +1980,7 @@ module OpenHAB
 
             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)
+              updated.trigger(item:, to: to_state, attach:)
             end
           end.flatten
         end
@@ -2027,7 +2016,7 @@ module OpenHAB
           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)
+            event("openhab/items/#{item.name}/timeseriesupdated", types: "ItemTimeSeriesUpdatedEvent", attach:)
           end
         end
 
@@ -2062,8 +2051,7 @@ module OpenHAB
         # @param [String] path Path to watch. Can be a directory or a file.
         # @param [String] glob
         #   Limit events to paths matching this glob. Globs are matched using `glob`
-        #   [PathMatcher](https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/nio/file/FileSystem.html#getPathMatcher(java.lang.String))
-        #   rules.
+        #   {java.nio.file.FileSystem#getPathMatcher(java.lang.String) PathMatcher} rules.
         # @param [Array<:created, :deleted, :modified>, :created, :deleted, :modified] for
         #   Types of changes to watch for.
         # @param [Object] attach object to be attached to the trigger
@@ -2125,7 +2113,7 @@ module OpenHAB
                   path: path.to_s,
                   types: types.map(&:to_s),
                   glob: glob.to_s,
-                  attach: attach)
+                  attach:)
         end
 
         # @!endgroup
@@ -2207,7 +2195,7 @@ module OpenHAB
         #
         def create_rule?
           @tags = DSL::Items::ItemBuilder.normalize_tags(*tags)
-          return true unless (tags & %w[Script Scene]).empty?
+          return true if tags.intersect?(%w[Script Scene])
 
           if !triggers?
             logger.warn "Rule '#{uid}' has no triggers, not creating rule"
@@ -2279,7 +2267,7 @@ module OpenHAB
 
           interval = binding.local_variable_get(:for)
           # This hash structure must match the parameter signature for Debouncer.new
-          @debounce_settings = { for: interval, leading: leading, idle_time: idle_time }
+          @debounce_settings = { for: interval, leading:, idle_time: }
         end
       end
     end

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

@@ -43,7 +43,7 @@ module OpenHAB
         #
         def append_trigger(type:, config:, attach: nil, conditions: nil, label: nil)
           config.transform_keys!(&:to_s)
-          RuleTriggers.trigger(type: type, config: config, label: label).tap do |trigger|
+          RuleTriggers.trigger(type:, config:, label:).tap do |trigger|
             logger.trace { "Appending trigger (#{trigger.inspect}) attach (#{attach}) conditions(#{conditions})" }
             @triggers << trigger
             @attachments[trigger.id] = attach if attach

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

@@ -31,14 +31,14 @@ module OpenHAB
                 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)
+              conditions = Conditions::Duration.new(to:, from:, duration:)
               label = NameInference.infer_rule_name_from_trigger(:changed,
                                                                  [item],
-                                                                 from: from,
-                                                                 to: to,
-                                                                 duration: duration)
+                                                                 from:,
+                                                                 to:,
+                                                                 duration:)
 
-              changed_trigger(item: item, from: nil, to: nil, attach: attach, conditions: conditions, label: label)
+              changed_trigger(item:, from: nil, to: nil, attach:, conditions:, label:)
             else
               # swap from/to w/ nil if from/to need to be processed in Ruby
               # rubocop:disable Style/ParallelAssignment
@@ -46,19 +46,20 @@ module OpenHAB
               to_proc, to = to, nil unless Conditions.state?(to)
               # rubocop:enable Style/ParallelAssignment
               conditions = Conditions::Generic.new(from: from_proc, to: to_proc) unless from_proc.nil? && to_proc.nil?
-              changed_trigger(item: item, from: from, to: to, attach: attach, conditions: conditions)
+              changed_trigger(item:, from:, to:, attach:, conditions:)
             end
           end
 
+          # @!visibility private
+          # @return [String] An item state change trigger
+          ITEM_STATE_CHANGE = "core.ItemStateChangeTrigger"
+
           private
 
           # @return [String] A thing status Change trigger
           THING_CHANGE = "core.ThingStatusChangeTrigger"
           private_constant :THING_CHANGE
 
-          # @return [String] An item state change trigger
-          ITEM_STATE_CHANGE = "core.ItemStateChangeTrigger"
-
           # @return [String] A group state change trigger for items in the group
           GROUP_STATE_CHANGE = "core.GroupStateChangeTrigger"
           private_constant :GROUP_STATE_CHANGE
@@ -75,16 +76,16 @@ module OpenHAB
           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)
+                             group(group: item, from:, to:)
                            when Core::Things::Thing,
                                 Core::Things::ThingUID
-                             thing(thing: item, from: from, to: to)
+                             thing(thing: item, from:, to:)
                            when Core::Things::Registry
-                             thing(thing: "*", from: from, to: to)
+                             thing(thing: "*", from:, to:)
                            else
-                             item(item: item, from: from, to: to)
+                             item(item:, from:, to:)
                            end
-            append_trigger(type: type, config: config, attach: attach, conditions: conditions, label: label)
+            append_trigger(type:, config:, attach:, conditions:, label:)
           end
 
           #
@@ -98,7 +99,7 @@ module OpenHAB
           #  second element is a Hash configuring trigger
           #
           def thing(thing:, from:, to:)
-            trigger_for_thing(thing: thing, type: THING_CHANGE, to: to, from: from)
+            trigger_for_thing(thing:, type: THING_CHANGE, to:, from:)
           end
 
           #

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

@@ -48,7 +48,7 @@ module OpenHAB
             config = { "channelUID" => channel }
             config["event"] = trigger.to_s unless trigger.nil?
             logger.trace { "Creating Channel Trigger for channels #{channel.inspect} and config #{config.inspect}" }
-            append_trigger(type: CHANNEL_EVENT, config: config, attach: attach)
+            append_trigger(type: CHANNEL_EVENT, config:, attach:)
           end
         end
       end

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

@@ -22,7 +22,7 @@ module OpenHAB
           #
           def trigger(item:, command:, attach:)
             unless Conditions.state?(command)
-              conditions = Conditions::Generic.new(command: command)
+              conditions = Conditions::Generic.new(command:)
               command = nil
             end
 
@@ -32,7 +32,7 @@ module OpenHAB
                              [ITEM_COMMAND, { "itemName" => item.name }]
                            end
             config["command"] = command.to_s unless command.nil?
-            append_trigger(type: type, config: config, attach: attach, conditions: conditions)
+            append_trigger(type:, config:, attach:, conditions:)
           end
 
           # @return [String] item command trigger

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

@@ -19,7 +19,7 @@ module OpenHAB
             # @param [java.time.temporal.TemporalAmount] duration to state must stay at specific value before triggering
             #
             def initialize(to:, from:, duration:)
-              @conditions = Generic.new(to: to, from: from)
+              @conditions = Generic.new(to:, from:)
               @duration = duration
               @timers = {}
               logger.trace do
@@ -35,7 +35,7 @@ module OpenHAB
               timer = @timers[inputs["triggeringItem"]&.name]
               if timer&.active?
                 process_active_timer(timer, inputs, mod, &block)
-              elsif @conditions.process(mod: mod, inputs: inputs)
+              elsif @conditions.process(mod:, inputs:)
                 logger.trace { "Trigger Guards Matched for #{self}, delaying rule execution" }
                 # Add timer and attach timer to delay object, and also state being tracked to so
                 # timer can be cancelled if state changes
@@ -80,7 +80,7 @@ module OpenHAB
             # @param [Hash] inputs rule trigger inputs
             # @param [Hash] mod rule trigger mods
             #
-            def process_active_timer(timer, inputs, mod, &block)
+            def process_active_timer(timer, inputs, mod, &)
               old_state = Conditions.old_state_from(inputs)
               new_state = Conditions.new_state_from(inputs)
               if @conditions.from? && new_state != @tracking_from &&
@@ -90,7 +90,7 @@ module OpenHAB
                 logger.trace { "Item changed from #{old_state} to #{new_state} for #{self}, canceling timer." }
                 timer.cancel
                 # Reprocess trigger delay after canceling to track new state (if guards matched, etc)
-                process(mod: mod, inputs: inputs, &block)
+                process(mod:, inputs:, &)
               end
             end
           end