openhab-scripting 5.15.1 → 5.17.0

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

@@ -1089,7 +1089,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 +1381,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 +1480,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 +1699,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 +1802,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 +2022,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 +2059,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

@@ -64,6 +64,8 @@ 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
@@ -136,6 +138,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

@@ -20,15 +20,15 @@ module OpenHAB
           #   in this module than instance variable belong to the module not the calling class
           define_method(name) do |*args, &block|
             if args.empty? && block.nil? == true
-              instance_variable_get("@#{name}")
+              instance_variable_get(:"@#{name}")
             else
               logger.trace("Property '#{name}' called with args(#{args}) and block(#{block})")
               if args.length == 1
-                instance_variable_set("@#{name}", args.first)
+                instance_variable_set(:"@#{name}", args.first)
               elsif args.length > 1
-                instance_variable_set("@#{name}", args)
+                instance_variable_set(:"@#{name}", args)
               elsif block
-                instance_variable_set("@#{name}", block)
+                instance_variable_set(:"@#{name}", block)
               end
             end
           end
@@ -47,7 +47,7 @@ module OpenHAB
           define_method(name) do |*args, &block|
             array_name ||= name
             if args.empty? && block.nil? == true
-              instance_variable_get("@#{array_name}")
+              instance_variable_get(:"@#{array_name}")
             else
               logger.trace("Property '#{name}' called with args(#{args}) and block(#{block})")
               if args.length == 1
@@ -59,14 +59,14 @@ module OpenHAB
               end
               yield insert if block_given?
               insert = wrapper.new(insert) if wrapper
-              instance_variable_set("@#{array_name}", (instance_variable_get("@#{array_name}") || []) << insert)
+              instance_variable_set(:"@#{array_name}", (instance_variable_get(:"@#{array_name}") || []) << insert)
             end
           end
 
           return unless array_name
 
           define_method(array_name) do
-            instance_variable_get("@#{array_name}")
+            instance_variable_get(:"@#{array_name}")
           end
         end
       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/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
@@ -174,10 +175,10 @@ module OpenHAB
           def self.duration_to_map(duration)
             if duration.to_millis_part.zero? && duration.to_nanos_part.zero? && duration.to_days.zero?
               %i[second minute hour].each do |unit|
-                to_unit_part = duration.public_send("to_#{unit}s_part")
+                to_unit_part = duration.public_send(:"to_#{unit}s_part")
                 next unless to_unit_part.positive?
 
-                to_unit = duration.public_send("to_#{unit}s")
+                to_unit = duration.public_send(:"to_#{unit}s")
                 break unless to_unit_part == to_unit
 
                 return EXPRESSION_MAP[unit].merge(unit => "*/#{to_unit}")
@@ -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)

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

@@ -1,120 +1,118 @@
 # frozen_string_literal: true
 
 # @deprecated OH3.4 this module is not needed in OH4+
-if Gem::Version.new(OpenHAB::Core::VERSION) < Gem::Version.new("4.0.0")
-
-  require "singleton"
-
-  require_relative "cron"
-
-  module OpenHAB
-    module DSL
-      module Rules
-        module Triggers
-          # @!visibility private
-          #
-          # Cron trigger handler that provides trigger ID
-          #
-          module CronHandler
-            # Cron Trigger Handler that provides trigger IDs
-            # Unfortunatly because the CronTriggerHandler in openHAB core is marked internal
-            # the entire thing must be recreated here
-            class CronTriggerHandler < org.openhab.core.automation.handler.BaseTriggerModuleHandler
-              include org.openhab.core.scheduler.SchedulerRunnable
-              include org.openhab.core.automation.handler.TimeBasedTriggerHandler
-
-              # Provides access to protected fields
-              field_accessor :callback
-
-              # Creates a new CronTriggerHandler
-              # @param [org.openhab.core.automation.Trigger] trigger openHAB trigger associated with handler
-              #
-              def initialize(trigger)
-                @trigger = trigger
-                @scheduler = OSGi.service("org.openhab.core.scheduler.CronScheduler")
-                @schedule = nil
-                @expression = trigger.configuration.get("cronExpression")
-                super(trigger)
-              end
+return unless OpenHAB::Core.version < OpenHAB::Core::V4_0
+
+require "singleton"
+
+require_relative "cron"
+
+module OpenHAB
+  module DSL
+    module Rules
+      module Triggers
+        # @!visibility private
+        #
+        # Cron trigger handler that provides trigger ID
+        #
+        module CronHandler
+          # Cron Trigger Handler that provides trigger IDs
+          # Unfortunatly because the CronTriggerHandler in openHAB core is marked internal
+          # the entire thing must be recreated here
+          class CronTriggerHandler < org.openhab.core.automation.handler.BaseTriggerModuleHandler
+            include org.openhab.core.scheduler.SchedulerRunnable
+            include org.openhab.core.automation.handler.TimeBasedTriggerHandler
+
+            # Provides access to protected fields
+            field_accessor :callback
+
+            # Creates a new CronTriggerHandler
+            # @param [org.openhab.core.automation.Trigger] trigger openHAB trigger associated with handler
+            #
+            def initialize(trigger)
+              @trigger = trigger
+              @scheduler = OSGi.service("org.openhab.core.scheduler.CronScheduler")
+              @schedule = nil
+              @expression = trigger.configuration.get("cronExpression")
+              super(trigger)
+            end
 
-              #
-              # Set the callback to execute when cron trigger fires
-              # @param [Object] callback to run
-              #
-              def setCallback(callback) # rubocop:disable Naming/MethodName
-                synchronized do
-                  super(callback)
-                  @schedule = @scheduler.schedule(self, @expression)
-                  logger.trace("Scheduled cron job '#{@expression}' for trigger '#{@trigger.id}'.")
-                end
+            #
+            # Set the callback to execute when cron trigger fires
+            # @param [Object] callback to run
+            #
+            def setCallback(callback) # rubocop:disable Naming/MethodName
+              synchronized do
+                super(callback)
+                @schedule = @scheduler.schedule(self, @expression)
+                logger.trace("Scheduled cron job '#{@expression}' for trigger '#{@trigger.id}'.")
               end
+            end
 
-              #
-              # Get the temporal adjuster
-              # @return [CronAdjuster]
-              #
-              def getTemporalAdjuster # rubocop:disable Naming/MethodName
-                org.openhab.core.scheduler.CronAdjuster.new(@expression)
-              end
+            #
+            # Get the temporal adjuster
+            # @return [CronAdjuster]
+            #
+            def getTemporalAdjuster # rubocop:disable Naming/MethodName
+              org.openhab.core.scheduler.CronAdjuster.new(@expression)
+            end
 
-              #
-              # Execute the callback
-              #
-              def run
-                callback&.triggered(@trigger, { "module" => @trigger.id })
-              end
+            #
+            # Execute the callback
+            #
+            def run
+              callback&.triggered(@trigger, { "module" => @trigger.id })
+            end
 
-              #
-              # Dispose of the handler
-              # cancel the cron scheduled task
-              #
-              def dispose
-                synchronized do
-                  super
-                  return unless @schedule
+            #
+            # Dispose of the handler
+            # cancel the cron scheduled task
+            #
+            def dispose
+              synchronized do
+                super
+                return unless @schedule
 
-                  @schedule.cancel(true)
-                  @schedule = nil
-                end
-                logger.trace("cancelled job for trigger '#{@trigger.id}'.")
+                @schedule.cancel(true)
+                @schedule = nil
               end
+              logger.trace("cancelled job for trigger '#{@trigger.id}'.")
             end
+          end
 
-            # Implements the ScriptedTriggerHandlerFactory interface to create a new Cron Trigger Handler
-            class CronTriggerHandlerFactory
-              include Singleton
-              include org.openhab.core.automation.module.script.rulesupport.shared.factories.ScriptedTriggerHandlerFactory # rubocop:disable Layout/LineLength
-
-              def initialize
-                Core.automation_manager.add_trigger_handler(
-                  Cron::CRON_TRIGGER_MODULE_ID,
-                  self
-                )
-
-                Core.automation_manager.add_trigger_type(org.openhab.core.automation.type.TriggerType.new(
-                                                           Cron::CRON_TRIGGER_MODULE_ID,
-                                                           nil,
-                                                           "A specific instant occurs",
-                                                           "Triggers when the specified instant occurs",
-                                                           nil,
-                                                           org.openhab.core.automation.Visibility::VISIBLE,
-                                                           nil
-                                                         ))
-                logger.trace("Added script cron trigger handler")
-              end
+          # Implements the ScriptedTriggerHandlerFactory interface to create a new Cron Trigger Handler
+          class CronTriggerHandlerFactory
+            include Singleton
+            include org.openhab.core.automation.module.script.rulesupport.shared.factories.ScriptedTriggerHandlerFactory
+
+            def initialize
+              Core.automation_manager.add_trigger_handler(
+                Cron::CRON_TRIGGER_MODULE_ID,
+                self
+              )
+
+              Core.automation_manager.add_trigger_type(org.openhab.core.automation.type.TriggerType.new(
+                                                         Cron::CRON_TRIGGER_MODULE_ID,
+                                                         nil,
+                                                         "A specific instant occurs",
+                                                         "Triggers when the specified instant occurs",
+                                                         nil,
+                                                         org.openhab.core.automation.Visibility::VISIBLE,
+                                                         nil
+                                                       ))
+              logger.trace("Added script cron trigger handler")
+            end
 
-              # Invoked by openHAB core to get a trigger handler for the supplied trigger
-              # @param [org.openhab.core.automation.Trigger] trigger
-              #
-              # @return [WatchTriggerHandler] trigger handler for supplied trigger
-              def get(trigger)
-                CronTriggerHandler.new(trigger)
-              end
+            # Invoked by openHAB core to get a trigger handler for the supplied trigger
+            # @param [org.openhab.core.automation.Trigger] trigger
+            #
+            # @return [CronTriggerHandler] trigger handler for supplied trigger
+            def get(trigger)
+              CronTriggerHandler.new(trigger)
             end
           end
         end
       end
     end
   end
-
 end

data/lib/openhab/dsl/rules/triggers/watch/watch_handler.rb

@@ -310,7 +310,7 @@ module OpenHAB
               logger.trace("Added watch trigger handler")
             end
 
-            # Invoked by openHAB core to get a trigger handler for the supllied trigger
+            # Invoked by openHAB core to get a trigger handler for the supplied trigger
             # @param [org.openhab.core.automation.Trigger] trigger
             #
             # @return [WatchTriggerHandler] trigger handler for supplied trigger

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

@@ -116,7 +116,7 @@ module OpenHAB
                        icon_color: nil,
                        visibility: nil,
                        &block)
-          unless SitemapBuilder.factory.respond_to?("create_#{type}")
+          unless SitemapBuilder.factory.respond_to?(:"create_#{type}")
             raise ArgumentError,
                   "#{type} is not a valid widget type"
           end
@@ -144,7 +144,7 @@ module OpenHAB
           if @builder_proxy
             old_obj = @builder_proxy.__getobj__
             @builder_proxy.__setobj__(self)
-            begin
+            DSL::ThreadLocal.thread_local(openhab_create_dummy_items: true) do
               yield @builder_proxy
             ensure
               @builder_proxy.__setobj__(old_obj)
@@ -183,7 +183,7 @@ module OpenHAB
 
         # @!visibility private
         def build
-          widget = SitemapBuilder.factory.send("create_#{@type}")
+          widget = SitemapBuilder.factory.send(:"create_#{@type}")
           item = @item
           item = item.name if item.respond_to?(:name)
           widget.item = item if item
@@ -281,9 +281,41 @@ module OpenHAB
       class SwitchBuilder < WidgetBuilder
         # Mappings from command to label
         #
-        # Keys can be any {Core::Types::Command command}, values are strings.
-        # If an array is given, the same value is used for both command and label.
+        # If a hash is given, the keys are the commands and the values are the labels.
+        # The keys can be any {Core::Types::Command command}, string or symbol.
+        # They will be converted to strings.
+        #
+        # If an array is given:
+        # - Scalar elements define the command, and the label is the same as the command.
+        # - Array elements contain the command, label, and optional third element for the icon.
+        # - Hash elements contain the command, label, and optional icon defined by the corresponding keys.
+        #
+        # @since openHAB 4.1 added support for icons
+        #
+        # @example A Hash to specify different command and label
+        #   switch mappings: { off: "Off", cool: "Cool", heat: "Heat" }
+        #
+        # @example A simple array with the same command and label
+        #   switch mappings: %w[off cool heat]
+        #
+        # @example An array of arrays containing the command, label, and icon
+        #   switch mappings: [
+        #     %w[off Off f7:power],
+        #     %w[cool Cool f7:snow],
+        #     %w[heat Heat f7:flame],
+        #     %w[auto Auto] # no icon
+        #   ]
+        #
+        # @example An array of hashes for the command, label, and icon
+        #   switch mappings: [
+        #     {command: "off", label: "Off", icon: "f7:power"},
+        #     {command: "cool", label: "Cool", icon: "f7:snow"},
+        #     {command: "heat", label: "Heat", icon: "f7:flame"},
+        #     {command: "auto", label: "Auto"} # no icon
+        #   ]
+        #
         # @return [Hash, Array, nil]
+        # @see LinkableWidgetBuilder#switch
         # @see https://www.openhab.org/docs/ui/sitemaps.html#mappings
         attr_accessor :mappings
 
@@ -300,10 +332,13 @@ module OpenHAB
         # @!visibility private
         def build
           widget = super
-          mappings&.each do |cmd, label|
+          mappings&.each do |cmd, label, icon|
             mapping = SitemapBuilder.factory.create_mapping
+            cmd, label, icon = cmd.values_at(:command, :label, :icon) if cmd.is_a?(Hash)
             mapping.cmd = cmd.to_s
             mapping.label = label&.to_s || cmd.to_s
+            # @deprecated OH 4.1 the if check is not needed in OH4.1+
+            mapping.icon = icon if icon
             widget.mappings.add(mapping)
           end
           widget

data/lib/openhab/dsl/version.rb

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

data/lib/openhab/dsl.rb

@@ -84,14 +84,17 @@ module OpenHAB
     # @param [String, nil] label The label for the profile. When nil, the profile will not be visible in the UI.
     # @param [org.openhab.core.config.core.ConfigDescription, nil] config_description
     #   The configuration description for the profile so that it can be configured in the UI.
-    # @yield [event, command: nil, state: nil, callback:, link:, item:, channel_uid:, configuration:, context:]
+    # @yield [event, command: nil, state: nil, time_series: nil, callback:, link:, item:, channel_uid:, configuration:, context:]
     #   All keyword params are optional. Any that aren't defined won't be passed.
-    # @yieldparam [:command_from_item, :state_from_item, :command_from_handler, :state_from_handler] event
+    # @yieldparam [:command_from_item, :state_from_item, :command_from_handler, :state_from_handler, :time_series_from_handler] event
     #   The event that needs to be processed.
     # @yieldparam [Command, nil] command
     #   The command being sent for `:command_from_item` and `:command_from_handler` events.
     # @yieldparam [State, nil] state
     #   The state being sent for `:state_from_item` and `:state_from_handler` events.
+    # @yieldparam [TimeSeries] time_series
+    #   The time series for `:time_series_from_handler` events.
+    #   Only available since openHAB 4.1.
     # @yieldparam [Core::Things::ProfileCallback] callback
     #   The callback to be used to customize the action taken.
     # @yieldparam [Core::Things::ItemChannelLink] link
@@ -105,6 +108,7 @@ module OpenHAB
     #
     # @see org.openhab.core.thing.profiles.Profile
     # @see org.openhab.core.thing.profiles.StateProfile
+    # @see org.openhab.core.thing.profiles.TimeSeriesProfile
     #
     # @example Vetoing a command
     #   profile(:veto_closing_shades) do |event, item:, command:|

data/lib/openhab/log.rb

@@ -210,7 +210,7 @@ module OpenHAB
       #   @return [true,false]
       #
       def def_level_predicate(level)
-        define_method("#{level}?") { @slf4j_logger.send("is_#{level}_enabled") }
+        define_method(:"#{level}?") { @slf4j_logger.send(:"is_#{level}_enabled") }
       end
     end
 
@@ -318,7 +318,7 @@ module OpenHAB
       raise ArgumentError, "Unknown Severity #{severity}" unless LEVELS.include? severity
 
       # Dynamically check enablement of underlying logger
-      return unless send("#{severity}?")
+      return unless send(:"#{severity}?")
 
       # Process block if no message provided
       msg = yield if msg.nil? && block_given?