openhab-scripting 4.39.0 → 4.41.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1fb1294914e9c3e343bef8f0c1aaca327dbaa5875d446ec3e507edc1f390c9c9
-  data.tar.gz: be121541f849f733505c6180557f88fdd98869d89e0a593c6fc48db0e7e6daf5
+  metadata.gz: 101fdd6964b1dd5eaefcf5ecaf528ecc01ca12c280440da11ce8646d10fbd67c
+  data.tar.gz: 40bf18765cc29aee28d9ae486cd7c965435f5cbcf8f47867559bb72ccec7f3d9
 SHA512:
-  metadata.gz: e6af3e7152dd02c9d98dea19f9bcaa4f474a20daac090941c1121705d177afec2498a2704462645d51b6e4e055efda1f0431702c0f7c6f126718b7994ef6baad
-  data.tar.gz: f9af8246710e44dc86719d10ba2577003293640e1c11885c054da9d23d0be8746e1103151c173672ddfab96ae218f5d717318ab72d628a194f7a243647ea885d
+  metadata.gz: 8a8ce171ac466b46f28e5a5abc59cc2de62a20d16210e58fb7ea33b6ee5a6ad0b9399afb40491142d52396cbbee33b5be444f4d5530176b9ac34764f06a4ec5b
+  data.tar.gz: 57171fa39cfc71afaa8d8cb7488e184ea031cf6f8b01a135410a97317399e8a478d6cf9691ba81168d023882c488b07de5f47a921e516a05589bd198731da8b8

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

@@ -9,9 +9,12 @@ module OpenHAB
         #
         # Comparison
         #
-        # @param [GenericItem, Types::Type, Object] other object to
+        # @param [GenericItem, Types::Type, Object, GenericItemObject] other object to
         #   compare to
         #
+        #   When comparing GenericItemObject on either side, perform object comparison
+        #   return 0 if the object is equal, or nil otherwise.
+        #
         #   If this item is +NULL+ or +UNDEF+, and +other+ is nil, they are
         #   considered equal
         #
@@ -28,21 +31,30 @@ module OpenHAB
         #
         def <=>(other)
           logger.trace("(#{self.class}) #{self} <=> #{other} (#{other.class})")
-          # if we're NULL or UNDEF, implement special logic
-          unless state?
-            # if comparing to nil, consider ourselves equal
-            return 0 if other.nil?
-            # if the other object is an Item, only consider equal if we're
-            # in the same _kind_ of UnDefType state
-            return raw_state == other.raw_state if other.is_a?(GenericItem) && !other.state?
 
-            # otherwise, it's a non-nil thing comparing to nil, which is undefined
-            return nil
+          if is_a?(OpenHAB::DSL::GenericItemObject) || other.is_a?(OpenHAB::DSL::GenericItemObject)
+            return eql?(other) ? 0 : nil
           end
 
+          # if we're NULL or UNDEF, implement special logic
+          return nil_comparison unless state?
+
           # delegate to how the state compares to the other object
           state <=> other
         end
+
+        # Special logic for NULL/UNDEF state comparison
+        # @!visibility private
+        def nil_comparison
+          # if comparing to nil, consider ourselves equal
+          return 0 if other.nil?
+          # if the other object is an Item, only consider equal if we're
+          # in the same _kind_ of UnDefType state
+          return raw_state == other.raw_state if other.is_a?(GenericItem) && !other.state?
+
+          # otherwise, it's a non-nil thing comparing to nil, which is undefined
+          nil
+        end
       end
     end
   end

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

@@ -1,8 +1,11 @@
 # frozen_string_literal: true
 
-require 'openhab/dsl/items/metadata'
-require 'openhab/dsl/items/persistence'
-require 'openhab/dsl/items/semantics'
+require 'delegate'
+require 'forwardable'
+
+require_relative 'metadata'
+require_relative 'persistence'
+require_relative 'semantics'
 
 require_relative 'item_equality'
 
@@ -170,6 +173,17 @@ module OpenHAB
           other.instance_of?(self.class) && hash == other.hash
         end
 
+        #
+        # A method to indicate that item comparison is requested instead of state comparison
+        #
+        # Example: Item1.item == items['Item1'].item should return true
+        #
+        # See ItemEquality#==
+        #
+        def item
+          @item ||= GenericItemObject.new(self)
+        end
+
         # @!method null?
         #   Check if the item state == +NULL+
         #   @return [Boolean]
@@ -201,5 +215,15 @@ module OpenHAB
         end
       end
     end
+
+    # A helper class to flag that item comparison is wanted instead of state comparison
+    # It is used by ItemEquality#===
+    class GenericItemObject < SimpleDelegator
+      extend Forwardable
+      include Log
+      include OpenHAB::DSL::Items::ItemEquality
+
+      def_delegator :__getobj__, :instance_of? # instance_of? is used by GenericItem#eql? to check for item equality
+    end
   end
 end

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

@@ -44,6 +44,7 @@ module OpenHAB
 
         include Enumerable
         include ComparableItem
+        prepend Semantics # make Semantics#points take precedence over Enumerable#points for GroupItem
 
         remove_method :==
 

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

@@ -22,7 +22,8 @@ module OpenHAB
         # @return [Boolean]
         #
         def ==(other)
-          logger.trace("(#{self.class}) #{self} == #{other} (#{other.class})")
+          logger.trace { "ItemEquality#== (#{self.class}) #{self} == #{other} (#{other.class})" }
+          return eql?(other) if generic_item_object?(other)
           return true if equal?(other) || eql?(other)
           return true if !state? && other.nil?
 
@@ -30,6 +31,28 @@ module OpenHAB
 
           state == other
         end
+
+        #
+        # Check item object equality for grep
+        #
+        def ===(other)
+          logger.trace { "ItemEquality#=== (#{self.class}) #{self} == #{other} (#{other.class})" }
+          eql?(other)
+        end
+
+        private
+
+        #
+        # Determines if an object equality check is required, based on whether
+        # either operand is a GenericItemObject
+        #
+        # @param [Object] other
+        #
+        # @return [Boolean]
+        #
+        def generic_item_object?(other)
+          other.is_a?(OpenHAB::DSL::GenericItemObject) || is_a?(OpenHAB::DSL::GenericItemObject)
+        end
       end
     end
   end

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

@@ -4,168 +4,165 @@ require_relative 'semantics/enumerable'
 
 module OpenHAB
   module DSL
-    # Module for implementing semantics helper methods on [GenericItem]
-    #
-    # Wraps https://www.openhab.org/javadoc/latest/org/openhab/core/model/script/actions/semantics,
-    # as well as adding a few additional convenience methods.
-    # Also includes Classes for each semantic tag.
-    #
-    # Be warned that the Semantic model is stricter than can actually be
-    # described by tags and groups on an Item. It makes assumptions that any
-    # given item only belongs to one semantic type (Location, Equipment, Point).
-    #
-    # See https://github.com/openhab/openhab-core/blob/main/bundles/org.openhab.core.semantics/model/SemanticTags.csv
-    module Semantics
-      # @!visibility private
-      # import the actual semantics action
-      SemanticsAction = org.openhab.core.model.script.actions.Semantics
-      private_constant :SemanticsAction
-
-      # import all the semantics constants
-      [org.openhab.core.semantics.model.point.Points,
-       org.openhab.core.semantics.model.property.Properties,
-       org.openhab.core.semantics.model.equipment.Equipments,
-       org.openhab.core.semantics.model.location.Locations].each do |parent_tag|
-        parent_tag.stream.for_each do |tag|
-          const_set(tag.simple_name.to_sym, tag.ruby_class)
+    module Items
+      # Module for implementing semantics helper methods on [GenericItem]
+      #
+      # Wraps https://www.openhab.org/javadoc/latest/org/openhab/core/model/script/actions/semantics,
+      # as well as adding a few additional convenience methods.
+      # Also includes Classes for each semantic tag.
+      #
+      # Be warned that the Semantic model is stricter than can actually be
+      # described by tags and groups on an Item. It makes assumptions that any
+      # given item only belongs to one semantic type (Location, Equipment, Point).
+      #
+      # See https://github.com/openhab/openhab-core/blob/main/bundles/org.openhab.core.semantics/model/SemanticTags.csv
+      module Semantics
+        # @!visibility private
+        # import the actual semantics action
+        SemanticsAction = org.openhab.core.model.script.actions.Semantics
+        private_constant :SemanticsAction
+
+        # import all the semantics constants
+        [org.openhab.core.semantics.model.point.Points,
+         org.openhab.core.semantics.model.property.Properties,
+         org.openhab.core.semantics.model.equipment.Equipments,
+         org.openhab.core.semantics.model.location.Locations].each do |parent_tag|
+          parent_tag.stream.for_each do |tag|
+            const_set(tag.simple_name.to_sym, tag.ruby_class)
+          end
         end
-      end
-
-      # put ourself into the global namespace, replacing the action
-      ::Semantics = self # rubocop:disable Naming/ConstantName
 
-      # Checks if this Item is a Location
-      #
-      # This is implemented as checking if the item's semantic_type
-      # is a Location. I.e. an Item has a single semantic_type.
-      #
-      # @return [true, false]
-      def location?
-        SemanticsAction.location?(self)
-      end
+        # put ourself into the global namespace, replacing the action
+        ::Semantics = self # rubocop:disable Naming/ConstantName
+
+        # Checks if this Item is a Location
+        #
+        # This is implemented as checking if the item's semantic_type
+        # is a Location. I.e. an Item has a single semantic_type.
+        #
+        # @return [true, false]
+        def location?
+          SemanticsAction.location?(self)
+        end
 
-      # Checks if this Item is an Equipment
-      #
-      # This is implemented as checking if the item's semantic_type
-      # is an Equipment. I.e. an Item has a single semantic_type.
-      #
-      # @return [true, false]
-      def equipment?
-        SemanticsAction.equipment?(self)
-      end
+        # Checks if this Item is an Equipment
+        #
+        # This is implemented as checking if the item's semantic_type
+        # is an Equipment. I.e. an Item has a single semantic_type.
+        #
+        # @return [true, false]
+        def equipment?
+          SemanticsAction.equipment?(self)
+        end
 
-      # Checks if this Item is a Point
-      #
-      # This is implemented as checking if the item's semantic_type
-      # is a Point. I.e. an Item has a single semantic_type.
-      #
-      # @return [true, false]
-      def point?
-        SemanticsAction.point?(self)
-      end
+        # Checks if this Item is a Point
+        #
+        # This is implemented as checking if the item's semantic_type
+        # is a Point. I.e. an Item has a single semantic_type.
+        #
+        # @return [true, false]
+        def point?
+          SemanticsAction.point?(self)
+        end
 
-      # Checks if this Item has any semantic tags
-      # @return [true, false]
-      def semantic?
-        !!semantic_type
-      end
+        # Checks if this Item has any semantic tags
+        # @return [true, false]
+        def semantic?
+          !!semantic_type
+        end
 
-      # Gets the related Location Item of this Item.
-      #
-      # Returns +self+ if this Item is a Location. Otherwise, checks ancestor
-      # groups one level at a time, returning the first Location Item found.
-      #
-      # @return [GenericItem, nil]
-      def location
-        SemanticsAction.get_location(self)
-      end
+        # Gets the related Location Item of this Item.
+        #
+        # Checks ancestor groups one level at a time, returning the first Location Item found.
+        #
+        # @return [GenericItem, nil]
+        def location
+          SemanticsAction.get_location(self)
+        end
 
-      # Returns the sub-class of [Location] related to this Item.
-      #
-      # In other words, the semantic_type of this Item's Location.
-      #
-      # @return [Class]
-      def location_type
-        SemanticsAction.get_location_type(self)&.ruby_class
-      end
+        # Returns the sub-class of [Location] related to this Item.
+        #
+        # In other words, the semantic_type of this Item's Location.
+        #
+        # @return [Class]
+        def location_type
+          SemanticsAction.get_location_type(self)&.ruby_class
+        end
 
-      # Gets the related Equipment Item of this Item.
-      #
-      # Returns +self+ if this Item is an Equipment. Otherwise, checks ancestor
-      # groups one level at a time, returning the first Equipment Item found.
-      #
-      # @return [GenericItem, nil]
-      def equipment
-        SemanticsAction.get_equipment(self)
-      end
+        # Gets the related Equipment Item of this Item.
+        #
+        # Checks ancestor groups one level at a time, returning the first Equipment Item found.
+        #
+        # @return [GenericItem, nil]
+        def equipment
+          SemanticsAction.get_equipment(self)
+        end
 
-      # Returns the sub-class of [Equipment] related to this Item.
-      #
-      # In other words, the semantic_type of this Item's Equipment.
-      #
-      # @return [Class]
-      def equipment_type
-        SemanticsAction.get_equipment_type(self)&.ruby_class
-      end
+        # Returns the sub-class of [Equipment] related to this Item.
+        #
+        # In other words, the semantic_type of this Item's Equipment.
+        #
+        # @return [Class]
+        def equipment_type
+          SemanticsAction.get_equipment_type(self)&.ruby_class
+        end
 
-      # Returns the sub-class of [Point] this Item is tagged with.
-      #
-      # @return [Class]
-      def point_type
-        SemanticsAction.get_point_type(self)&.ruby_class
-      end
+        # Returns the sub-class of [Point] this Item is tagged with.
+        #
+        # @return [Class]
+        def point_type
+          SemanticsAction.get_point_type(self)&.ruby_class
+        end
 
-      # Returns the sub-class of [Property] this Item is tagged with.
-      # @return [Class]
-      def property_type
-        SemanticsAction.get_property_type(self)&.ruby_class
-      end
+        # Returns the sub-class of [Property] this Item is tagged with.
+        # @return [Class]
+        def property_type
+          SemanticsAction.get_property_type(self)&.ruby_class
+        end
 
-      # Returns the sub-class of [Tag] this Item is tagged with.
-      #
-      # It will only return the first applicable Tag, preferring
-      # a sub-class of [Location], [Equipment], or [Point] first,
-      # and if none of those are found, looks for a [Property].
-      # @return [Class]
-      def semantic_type
-        SemanticsAction.get_semantic_type(self)&.ruby_class
-      end
+        # Returns the sub-class of [Tag] this Item is tagged with.
+        #
+        # It will only return the first applicable Tag, preferring
+        # a sub-class of [Location], [Equipment], or [Point] first,
+        # and if none of those are found, looks for a [Property].
+        # @return [Class]
+        def semantic_type
+          SemanticsAction.get_semantic_type(self)&.ruby_class
+        end
 
-      # Return the related Point Items.
-      #
-      # Searches this Equipment Item for Points that are tagged appropriately.
-      #
-      # If called on a Point Item, it will automatically search for sibling Points
-      # (and remove itself if found).
-      #
-      # @example Get all points for a TV
-      #   eGreatTV.points
-      # @example Search an Equipment item for its switch
-      #   eGuestFan.points(Semantics::Switch) # => [GuestFan_Dimmer]
-      # @example Search a Thermostat item for its current temperature item
-      #   eFamilyThermostat.points(Semantics::Status, Semantics::Temperature)
-      #   # => [FamilyThermostat_AmbTemp]
-      # @example Search a Thermostat item for is setpoints
-      #   eFamilyThermostat.points(Semantics::Control, Semantics::Temperature)
-      #   # => [FamilyThermostat_HeatingSetpoint, FamilyThermostat_CoolingSetpoint]
-      # @example Given a A/V receiver's input item, search for its power item
-      #   FamilyReceiver_Input.points(Semantics::Switch) # => [FamilyReceiver_Switch]
-      #
-      # @param [Class] point_or_property_types
-      #   Pass 1 or 2 classes that are sub-classes of [Point] or [Property].
-      #   Note that when comparing against semantic tags, it does a sub-class check.
-      #   So if you search for [Control], you'll get items tagged with [Switch].
-      # @return [Array<GenericItem>]
-      def points(*point_or_property_types)
-        # automatically search the parent equipment (or location?!) for sibling points
-        unless equipment? || location?
+        # Return the related Point Items.
+        #
+        # Searches this Equipment Item for Points that are tagged appropriately.
+        #
+        # If called on a Point Item, it will automatically search for sibling Points
+        # (and remove itself if found).
+        #
+        # @example Get all points for a TV
+        #   eGreatTV.points
+        # @example Search an Equipment item for its switch
+        #   eGuestFan.points(Semantics::Switch) # => [GuestFan_Dimmer]
+        # @example Search a Thermostat item for its current temperature item
+        #   eFamilyThermostat.points(Semantics::Status, Semantics::Temperature)
+        #   # => [FamilyThermostat_AmbTemp]
+        # @example Search a Thermostat item for is setpoints
+        #   eFamilyThermostat.points(Semantics::Control, Semantics::Temperature)
+        #   # => [FamilyThermostat_HeatingSetpoint, FamilyThermostat_CoolingSetpoint]
+        # @example Given a A/V receiver's input item, search for its power item
+        #   FamilyReceiver_Input.points(Semantics::Switch) # => [FamilyReceiver_Switch]
+        #
+        # @param [Class] point_or_property_types
+        #   Pass 1 or 2 classes that are sub-classes of [Point] or [Property].
+        #   Note that when comparing against semantic tags, it does a sub-class check.
+        #   So if you search for [Control], you'll get items tagged with [Switch].
+        # @return [Array<GenericItem>]
+        def points(*point_or_property_types)
+          return members.points(*point_or_property_types) if equipment? || location?
+
+          # automatically search the parent equipment (or location?!) for sibling points
           result = (equipment || location)&.points(*point_or_property_types) || []
           # remove self. but avoid state comparisons
           result.delete_if { |item| item.eql?(self) }
-          return result
         end
-
-        members.points(*point_or_property_types)
       end
     end
   end
@@ -174,21 +171,27 @@ end
 # Additions to Enumerable to allow easily filtering groups of items based on the semantic model
 module Enumerable
   # Returns a new array of items that are a semantics Location (optionally of the given type)
-  def sublocations(type = nil)
-    raise ArgumentError, 'type must be a subclass of Location' if type && !(type < OpenHAB::DSL::Semantics::Location)
+  def locations(type = nil)
+    if type && !(type < OpenHAB::DSL::Items::Semantics::Location)
+      raise ArgumentError, 'type must be a subclass of Location'
+    end
 
     result = select(&:location?)
     result.select! { |i| i.location_type <= type } if type
 
     result
   end
+  # @deprecated Please use {#locations}
+  alias sublocations locations
 
   # Returns a new array of items that are a semantics equipment (optionally of the given type)
   #
   # @example Get all TVs in a room
   #   lGreatRoom.equipments(Semantics::Screen)
   def equipments(type = nil)
-    raise ArgumentError, 'type must be a subclass of Equipment' if type && !(type < OpenHAB::DSL::Semantics::Equipment)
+    if type && !(type < OpenHAB::DSL::Items::Semantics::Equipment)
+      raise ArgumentError, 'type must be a subclass of Equipment'
+    end
 
     result = select(&:equipment?)
     result.select! { |i| i.equipment_type <= type } if type
@@ -205,36 +208,20 @@ module Enumerable
       raise ArgumentError, "wrong number of arguments (given #{point_or_property_types.length}, expected 0..2)"
     end
     unless point_or_property_types.all? do |tag|
-             tag < OpenHAB::DSL::Semantics::Point || tag < OpenHAB::DSL::Semantics::Property
+             tag < OpenHAB::DSL::Items::Semantics::Point || tag < OpenHAB::DSL::Items::Semantics::Property
            end
       raise ArgumentError, 'point_or_property_types must all be a subclass of Point or Property'
     end
-    if point_or_property_types.count { |tag| tag < OpenHAB::DSL::Semantics::Point } > 1 ||
-       point_or_property_types.count { |tag| tag < OpenHAB::DSL::Semantics::Property } > 1
+    if point_or_property_types.count { |tag| tag < OpenHAB::DSL::Items::Semantics::Point } > 1 ||
+       point_or_property_types.count { |tag| tag < OpenHAB::DSL::Items::Semantics::Property } > 1
       raise ArgumentError, 'point_or_property_types cannot both be a subclass of Point or Property'
     end
 
-    filter_with_members(&:point?)
-      .select do |point|
-      point_or_property_types.all? do |tag|
-        (tag < OpenHAB::DSL::Semantics::Point && point.point_type&.<=(tag)) ||
-          (tag < OpenHAB::DSL::Semantics::Property && point.property_type&.<=(tag))
+    select do |point|
+      point.point? && point_or_property_types.all? do |tag|
+        (tag < OpenHAB::DSL::Items::Semantics::Point && point.point_type <= tag) ||
+          (tag < OpenHAB::DSL::Items::Semantics::Property && point.property_type&.<=(tag))
       end
     end
   end
-
-  #
-  # Select the elements where the given block returns true.
-  # If the block returns false but the element is a GroupItem with members,
-  # merge its members into the result and filter them using the same block
-  #
-  # @param [Block] &block A block that returns true for the elements and members to be included in the result
-  #
-  # @return [Array] The resulting array
-  #
-  # !@visibility private
-  def filter_with_members(&block)
-    selected, others = partition(&block)
-    others.members.select(&block).concat(selected)
-  end
 end

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

@@ -35,7 +35,7 @@ module OpenHAB
         #
         # @param [String] expression OpenHAB style cron expression
         # @param [Object] attach object to be attached to the trigger
-        # @param [Hash] elements cron expression elements (second, minute, hour, dom, month, dow, year)
+        # @param [Hash] fields cron expression elements (second, minute, hour, dom, month, dow, year)
         #
         def cron(expression = nil, attach: nil, **fields)
           if fields.any?
@@ -124,7 +124,7 @@ module OpenHAB
           #
           # Create a cron map from a MonthDay
           #
-          # @param [Java::JavaTime::MonthDay] month_day
+          # @param [Java::JavaTime::MonthDay] monthday a {MonthDay} object
           # @param [Object] at TimeOfDay or String representing time of day
           #
           # @return [Hash] map describing cron expression
@@ -152,7 +152,7 @@ module OpenHAB
           #
           # Create a cron map from cron elements
           #
-          # @param [Hash] elements Cron fields (second, minute, hour, dom, month, dow, year)
+          # @param [Hash] fields Cron fields (second, minute, hour, dom, month, dow, year)
           #
           # @return [Hash] map describing cron expression
           #

data/lib/openhab/dsl/states.rb

@@ -33,7 +33,7 @@ module OpenHAB
       # Check if all the given items have a state (not UNDEF or NULL)
       #
       # @param [Array] items whose state must be non-nil
-      # @param [<Type>] check_things when true, also ensures that all linked things are online
+      # @param [<Type>] things when true, also ensures that all linked things are online
       #
       # @return [Boolean] true if all the items have a state, false otherwise
       #
@@ -51,7 +51,7 @@ module OpenHAB
         #
         # Create a StateStorage object that stores the states of the given items
         #
-        # @param [Array<Item>] *items A list of items
+        # @param [Array<Item>] items A list of items
         #
         # @return [StateStorage] A state storage object
         #

data/lib/openhab/dsl/types/point_type.rb

@@ -57,7 +57,7 @@ module OpenHAB
         # @return [Boolean]
         #
         def ==(other) # rubocop:disable Metrics
-          logger.trace("(#{self.class}) #{self} == #{other} (#{other.class})")
+          logger.trace { "(#{self.class}) #{self} == #{other} (#{other.class})" }
           if other.is_a?(Items::LocationItem) ||
              (other.is_a?(Items::GroupItem) && other.base_item.is_a?(LocationItem))
             return false unless other.state?

data/lib/openhab/dsl/types/type.rb

@@ -48,8 +48,8 @@ module OpenHAB
         #                   or item state of the same type
         #
         def ===(other)
-          logger.trace("(#{self.class}) #{self} === #{other} (#{other.class})")
-          other = other.state if other.respond_to?(:state)
+          logger.trace { "Type (#{self.class}) #{self} === #{other} (#{other.class})" }
+          other = other.state if other.respond_to?(:state) && !other.is_a?(OpenHAB::DSL::GenericItemObject)
           return false unless instance_of?(other.class)
 
           eql?(other)
@@ -62,7 +62,7 @@ module OpenHAB
         #   type conversions
         #
         def ==(other) # rubocop:disable Metrics
-          logger.trace("(#{self.class}) #{self} == #{other} (#{other.class})")
+          logger.trace { "(#{self.class}) #{self} == #{other} (#{other.class})" }
           return true if equal?(other)
 
           # i.e. ON == OFF, REFRESH == ON, ON == REFRESH

data/lib/openhab/log/logger.rb

@@ -54,7 +54,9 @@ module OpenHAB
         define_method(level) do |msg = nil, &block|
           log(severity: level, msg: msg, &block)
         end
-        define_method("#{level}_enabled?") { @sl4fj_logger.send("is_#{level}_enabled") }
+        define_method("#{level}?") { @sl4fj_logger.send("is_#{level}_enabled") }
+        # @deprecated
+        alias_method "#{level}_enabled?", "#{level}?"
       end
 
       #
@@ -62,7 +64,7 @@ module OpenHAB
       # @param [String] preamble to put at start of log message
       # @param [Hash] kwargs key and values to log
       def state(preamble = 'State:', **kwargs)
-        return unless trace_enabled?
+        return unless trace?
 
         states = kwargs.transform_keys(&:to_s)
                        .transform_keys(&:capitalize)
@@ -82,7 +84,7 @@ module OpenHAB
       # @return [Exception] the exception, potentially with a cleaned backtrace.
       #
       def clean_backtrace(error)
-        return error if debug_enabled?
+        return error if debug?
 
         if error.respond_to? :backtrace_locations
           backtrace = error.backtrace_locations.map(&:to_s).grep_v(INTERNAL_CALL_REGEX)
@@ -122,7 +124,7 @@ module OpenHAB
         raise ArgumentError, "Unknown Severity #{severity}" unless LEVELS.include? severity
 
         # Dynamically check enablement of underlying logger, this expands to "is_<level>_enabled"
-        return unless send("#{severity}_enabled?")
+        return unless send("#{severity}?")
 
         # Process block if no message provided
         msg = yield if msg.nil? && block_given?

data/lib/openhab/version.rb

@@ -5,5 +5,5 @@
 #
 module OpenHAB
   # @return [String] Version of OpenHAB helper libraries
-  VERSION = '4.39.0'
+  VERSION = '4.41.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: openhab-scripting
 version: !ruby/object:Gem::Version
-  version: 4.39.0
+  version: 4.41.0
 platform: ruby
 authors:
 - Brian O'Connell
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2022-04-20 00:00:00.000000000 Z
+date: 2022-04-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler