openhab-scripting 5.18.1 → 5.19.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cfc9ae60d0f82fc677a157ac0efd58c12fc597f5ac8f3d79d7aa9c472e2c5d3a
-  data.tar.gz: b8bf1721d064b2f88554722518496aa6c53b89407a9fb212880972725e49901f
+  metadata.gz: 806939292f4f749b0fd1db95f1b99a35365f8de972e96b90bb824a217f151743
+  data.tar.gz: 783bd04b6bcb2d6fedef08d69aecb150f3578a9a6a011015b968cb4614949263
 SHA512:
-  metadata.gz: 8e50f4ce2c5832a39b3ab9c7b7a489b22697a23b20ce803a633f28ea9b44ed2661a820cdefd00bc54c71cb212a2c1a1d96c35c413937cd3ac514aec55a4c13da
-  data.tar.gz: a298851e7255074cb21d9fd4e495a8c8dc750425b0db3319ab17353c2e07106e0f669a40912bbe98cc6db9f252ff70ebe68b9c94fb7366c4b257200da13eefda
+  metadata.gz: 11e236b0c0c642d154e0340ce1330311fcaec8f60c180af58ec4bfc2fd013a2de64d54ae327316b90bf565f5255c76c1f3d810595225d9c8b22ff40c8fb12e7b
+  data.tar.gz: 47d995352bb04ced923551adcf16f7022823b2cf4e2aed9d758be688fa9a75cc40b0778700e2e0e04f15e8092453ae2c0323565de9dc73047faaeff37d0bd397

data/lib/openhab/core/dto/item_channel_link.rb

@@ -27,6 +27,11 @@ module OpenHAB
         def channel_uid
           Things::ChannelUID.new(channelUID)
         end
+
+        # @return [String]
+        def to_s
+          "#{item_name} -> #{channelUID}"
+        end
       end
     end
   end

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

@@ -288,7 +288,7 @@ module OpenHAB
         end
 
         # @!attribute channel [r]
-        # Return the the channel this item is linked to. If an item is linked to more than one channel,
+        # Return the channel this item is linked to. If an item is linked to more than one channel,
         # this method only returns the first channel.
         #
         # @return [Things::Channel, nil]
@@ -320,7 +320,7 @@ module OpenHAB
         # @see unlink
         #
         def links
-          ItemChannelLinks.new(self, Things::Links::Provider.registry.get_links(name))
+          ItemChannelLinks.new(name, Things::Links::Provider.registry.get_links(name))
         end
 
         #

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

@@ -12,13 +12,13 @@ module OpenHAB
       #
       class ItemChannelLinks < SimpleDelegator
         #
-        # @param [Item] item The item that the links belong to
+        # @param [String, UID] owner The owner that the links belong to
         # @param [Set<ItemChannelLink>] links The set of links to delegate to
         #
         # @!visibility private
-        def initialize(item, links)
+        def initialize(owner, links)
           super(links)
-          @item = item
+          @owner = owner
         end
 
         #
@@ -27,7 +27,11 @@ module OpenHAB
         #
         def clear
           Things::Links::Provider.registry.all.each do |link|
-            next unless link.item_name == @item.name
+            if @owner.is_a?(String)
+              next unless link.item_name == @owner
+            else
+              next unless link.linked_uid == @owner
+            end
 
             provider = Things::Links::Provider.registry.provider_for(link.uid)
             if provider.is_a?(ManagedProvider)

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

@@ -33,7 +33,7 @@ module OpenHAB
       #     logger.info("The power usage exceeded its 15 min average)
       #   end
       #
-      # @example HistoricState
+      # @example PersistedState
       #   max = Power_Usage.maximum_since(LocalTime::MIDNIGHT)
       #   logger.info("Max power usage today: #{max}, at: #{max.timestamp})
       #
@@ -41,69 +41,50 @@ module OpenHAB
         GenericItem.prepend(self)
 
         #
-        # A state class with an added timestamp attribute.
+        # A wrapper for {org.openhab.core.persistence.HistoricItem HistoricItem} that delegates to its state.
         #
-        # This wraps {org.openhab.core.persistence.HistoricItem HistoricItem}
-        # to allow implicitly treating the object as its state, and wrapping of
-        # that state into a {QuantityType} as necessary.
+        # @example
+        #   max = Power_Usage.maximum_since(LocalTime::MIDNIGHT)
+        #   logger.info "Highest power usage: #{max} occurred at #{max.timestamp}" if max > 5 | "kW"
         #
-        class HistoricState < SimpleDelegator
+        class PersistedState < SimpleDelegator
+          extend Forwardable
+
           # @!attribute [r] state
           # @return [Types::State]
           alias_method :state, :__getobj__
 
-          def initialize(state, historic_item)
-            @historic_item = historic_item
-            super(state)
-          end
-
           # @!attribute [r] timestamp
           # @return [ZonedDateTime]
-          def timestamp
-            @historic_item.timestamp
+
+          # @!attribute [r] name
+          # @return [String] Item name
+
+          delegate %i[timestamp name] => :@historic_item
+
+          def initialize(historic_item, state = nil)
+            @historic_item = historic_item
+            super(state || historic_item.state)
           end
         end
 
-        # All persistence methods that could return a QuantityType
-        QUANTITY_METHODS = %i[average_since
-                              delta_since
-                              deviation_since
-                              sum_since
-                              variance_since].freeze
-
-        # All persistence methods that require a timestamp
-        # Note the _between methods are automatically created from the _since methods
-        PERSISTENCE_METHODS = (QUANTITY_METHODS +
-                              %i[ changed_since?
-                                  count_since
-                                  count_state_changes_since
-                                  historic_state
-                                  maximum_since
-                                  minimum_since
-                                  updated_since?])
-
-        # @deprecated OH3.4 - in openHAB 4, just add :get_all_states_since and freeze the list above
-        PERSISTENCE_METHODS << :get_all_states_since if OpenHAB::Core.version >= OpenHAB::Core::V4_0
-        PERSISTENCE_METHODS.freeze
-
-        private_constant :QUANTITY_METHODS, :PERSISTENCE_METHODS
-
-        # @!method persist(service = nil)
-        #   Persists the state of the item
-        #   @param [Symbol, String] service An optional persistence id instead of the default persistence service.
-        #   @return [void]
-
-        # @!method last_update(service = nil)
-        #   Returns the time the item was last updated.
-        #   @param [Symbol, String] service An optional persistence id instead of the default persistence service.
-        #   @return [ZonedDateTime, nil] The timestamp of the last update
+        # @deprecated Use {PersistedState} instead
+        HistoricState = PersistedState
 
         # @!method average_since(timestamp, service = nil)
         #   Returns the average value of the item's state since the given time
         #   @param [#to_zoned_date_time] timestamp The point in time from which to search
         #   @param [Symbol, String] service An optional persistence id instead of the default persistence service.
         #   @return [DecimalType, QuantityType, nil] The average value since `timestamp`,
-        #     or nil if no previous state could be found.
+        #     or nil if no previous states could be found.
+
+        # @!method average_until(timestamp, service = nil)
+        #   Returns the average value of the item's state between now until the given time
+        #   @param [#to_zoned_date_time] timestamp The point in time until which to search
+        #   @param [Symbol, String] service An optional persistence id instead of the default persistence service.
+        #   @return [DecimalType, QuantityType, nil] The average value until `timestamp`,
+        #     or nil if no future states could be found.
+        #   @since openHAB 4.2
 
         # @!method average_between(start, finish, service = nil)
         #   Returns the average value of the item's state between two points in time
@@ -111,14 +92,22 @@ module OpenHAB
         #   @param [#to_zoned_date_time] finish The point in time to which to search
         #   @param [Symbol, String] service An optional persistence id instead of the default persistence service.
         #   @return [DecimalType, QuantityType, nil] The average value between `start` and `finish`,
-        #     or nil if no previous state could be found.
+        #     or nil if no states could be found.
 
         # @!method delta_since(timestamp, service = nil)
         #   Returns the difference value of the item's state since the given time
         #   @param [#to_zoned_date_time] timestamp The point in time from which to search
         #   @param [Symbol, String] service An optional persistence id instead of the default persistence service.
         #   @return [DecimalType, QuantityType, nil] The difference value since `timestamp`,
-        #     or nil if no previous state could be found.
+        #     or nil if no previous states could be found.
+
+        # @!method delta_until(timestamp, service = nil)
+        #   Returns the difference value of the item's state between now until the given time
+        #   @param [#to_zoned_date_time] timestamp The point in time until which to search
+        #   @param [Symbol, String] service An optional persistence id instead of the default persistence service.
+        #   @return [DecimalType, QuantityType, nil] The difference value until `timestamp`,
+        #     or nil if no future states could be found.
+        #   @since openHAB 4.2
 
         # @!method delta_between(start, finish, service = nil)
         #   Returns the difference value of the item's state between two points in time
@@ -126,14 +115,22 @@ module OpenHAB
         #   @param [#to_zoned_date_time] finish The point in time to which to search
         #   @param [Symbol, String] service An optional persistence id instead of the default persistence service.
         #   @return [DecimalType, QuantityType, nil] The difference value between `start` and `finish`,
-        #     or nil if no previous state could be found.
+        #     or nil if no states could be found.
 
         # @!method deviation_since(timestamp, service = nil)
         #   Returns the standard deviation of the item's state since the given time
         #   @param [#to_zoned_date_time] timestamp The point in time from which to search
         #   @param [Symbol, String] service An optional persistence id instead of the default persistence service.
         #   @return [DecimalType, QuantityType, nil] The standard deviation since `timestamp`,
-        #     or nil if no previous state could be found.
+        #     or nil if no previous states could be found.
+
+        # @!method deviation_until(timestamp, service = nil)
+        #   Returns the standard deviation of the item's state beetween now until the given time
+        #   @param [#to_zoned_date_time] timestamp The point in time until which to search
+        #   @param [Symbol, String] service An optional persistence id instead of the default persistence service.
+        #   @return [DecimalType, QuantityType, nil] The standard deviation until `timestamp`,
+        #     or nil if no future states could be found.
+        #   @since openHAB 4.2
 
         # @!method deviation_between(start, finish, service = nil)
         #   Returns the standard deviation of the item's state between two points in time
@@ -141,14 +138,22 @@ module OpenHAB
         #   @param [#to_zoned_date_time] finish The point in time to which to search
         #   @param [Symbol, String] service An optional persistence id instead of the default persistence service.
         #   @return [DecimalType, QuantityType, nil] The standard deviation between `start` and `finish`,
-        #     or nil if no previous state could be found.
+        #     or nil if no states could be found.
 
         # @!method sum_since(timestamp, service = nil)
         #   Returns the sum of the item's state since the given time
         #   @param [#to_zoned_date_time] timestamp The point in time from which to search
         #   @param [Symbol, String] service An optional persistence id instead of the default persistence service.
         #   @return [DecimalType, QuantityType, nil] The sum since `timestamp`,
-        #     or nil if no previous state could be found.
+        #     or nil if no previous states could be found.
+
+        # @!method sum_until(timestamp, service = nil)
+        #   Returns the sum of the item's state between now until the given time
+        #   @param [#to_zoned_date_time] timestamp The point in time until which to search
+        #   @param [Symbol, String] service An optional persistence id instead of the default persistence service.
+        #   @return [DecimalType, QuantityType, nil] The sum until `timestamp`,
+        #     or nil if no future states could be found.
+        #   @since openHAB 4.2
 
         # @!method sum_between(start, finish, service = nil)
         #   Returns the sum of the item's state between two points in time
@@ -156,14 +161,22 @@ module OpenHAB
         #   @param [#to_zoned_date_time] finish The point in time to which to search
         #   @param [Symbol, String] service An optional persistence id instead of the default persistence service.
         #   @return [DecimalType, QuantityType, nil] The sum between `start` and `finish`,
-        #     or nil if no previous state could be found.
+        #     or nil if no states could be found.
 
         # @!method variance_since(timestamp, service = nil)
         #   Returns the variance of the item's state since the given time
         #   @param [#to_zoned_date_time] timestamp The point in time from which to search
         #   @param [Symbol, String] service An optional persistence id instead of the default persistence service.
         #   @return [DecimalType, QuantityType, nil] The variance since `timestamp`,
-        #     or nil if no previous state could be found.
+        #     or nil if no previous states could be found.
+
+        # @!method variance_until(timestamp, service = nil)
+        #   Returns the variance of the item's state between now until the given time
+        #   @param [#to_zoned_date_time] timestamp The point in time until which to search
+        #   @param [Symbol, String] service An optional persistence id instead of the default persistence service.
+        #   @return [DecimalType, QuantityType, nil] The variance until `timestamp`,
+        #     or nil if no future states could be found.
+        #   @since openHAB 4.2
 
         # @!method variance_between(start, finish, service = nil)
         #   Returns the variance of the item's state between two points in time
@@ -171,7 +184,7 @@ module OpenHAB
         #   @param [#to_zoned_date_time] finish The point in time to which to search
         #   @param [Symbol, String] service An optional persistence id instead of the default persistence service.
         #   @return [DecimalType, QuantityType, nil] The variance between `start` and `finish`,
-        #     or nil if no previous state could be found.
+        #     or nil if no states could be found.
 
         # @!method changed_since?(timestamp, service = nil)
         #   Whether the item's state has changed since the given time
@@ -179,6 +192,13 @@ module OpenHAB
         #   @param [Symbol, String] service An optional persistence id instead of the default persistence service.
         #   @return [true,false] True if the item's state has changed since the given `timestamp`, False otherwise.
 
+        # @!method changed_until?(timestamp, service = nil)
+        #   Whether the item's state has changed between now until the given time
+        #   @param [#to_zoned_date_time] timestamp The point in time until which to search
+        #   @param [Symbol, String] service An optional persistence id instead of the default persistence service.
+        #   @return [true,false] True if the item's state has changed until the given `timestamp`, False otherwise.
+        #   @since openHAB 4.2
+
         # @!method changed_between?(start, finish, service = nil)
         #   Whether the item's state changed between two points in time
         #   @param [#to_zoned_date_time] start The point in time from which to search
@@ -188,58 +208,111 @@ module OpenHAB
 
         # @!method evolution_rate(timestamp, service = nil)
         #   Returns the evolution rate of the item's state
-        #   @return [DecimalType, QuantityType, nil] The evolution rate since `timestamp`,
-        #     or nil if no previous state could be found.
+        #   @return [DecimalType, nil] The evolution rate or nil if no previous state could be found.
+        #   @deprecated This method has been deprecated in openHAB 4.2.
+        #     Use {#evolution_rate_since} or {#evolution_rate_between} instead.
         #   @overload evolution_rate(timestamp, service = nil)
         #     Returns the evolution rate of the item's state since the given time
         #     @param [#to_zoned_date_time] timestamp The point in time from which to search
         #     @param [Symbol, String] service An optional persistence id instead of the default persistence service.
-        #     @return [DecimalType, QuantityType, nil] The evolution rate since `timestamp`,
+        #     @return [DecimalType, nil] The evolution rate since `timestamp`,
         #       or nil if no previous state could be found.
+        #     @deprecated In openHAB 4.2, use {#evolution_rate_since} instead
         #   @overload evolution_rate(start, finish, service = nil)
         #     Returns the evolution rate of the item's state between two points in time
         #     @param [#to_zoned_date_time] start The point in time from which to search
         #     @param [#to_zoned_date_time] finish The point in time to which to search
         #     @param [Symbol, String] service An optional persistence id instead of the default persistence service.
-        #     @return [DecimalType, QuantityType, nil] The evolution rate between `start` and `finish`,
+        #     @return [DecimalType, nil] The evolution rate between `start` and `finish`,
         #       or nil if no previous state could be found.
+        #     @deprecated In openHAB 4.2, use {#evolution_rate_between} instead
+
+        # @!method evolution_rate_since(timestamp, service = nil)
+        #   Returns the evolution rate of the item's state since the given time
+        #   @param [#to_zoned_date_time] timestamp The point in time from which to search
+        #   @param [Symbol, String] service An optional persistence id instead of the default persistence service.
+        #   @return [DecimalType, nil] The evolution rate since `timestamp`,
+        #     or nil if no previous states could be found.
+        #   @since openHAB 4.2
+
+        # @!method evolution_rate_until(timestamp, service = nil)
+        #   Returns the evolution rate of the item's state between now until the given time
+        #   @param [#to_zoned_date_time] timestamp The point in time until which to search
+        #   @param [Symbol, String] service An optional persistence id instead of the default persistence service.
+        #   @return [DecimalType, nil] The evolution rate until `timestamp`,
+        #     or nil if no future states could be found.
+        #   @since openHAB 4.2
+
+        # @!method evolution_rate_between(start, finish, service = nil)
+        #   Returns the evolution rate of the item's state between two points in time
+        #   @param [#to_zoned_date_time] start The point in time from which to search
+        #   @param [#to_zoned_date_time] finish The point in time to which to search
+        #   @param [Symbol, String] service An optional persistence id instead of the default persistence service.
+        #   @return [DecimalType, nil] The evolution rate between `start` and `finish`,
+        #     or nil if no states could be found.
+        #   @since openHAB 4.2
 
         # @!method historic_state(timestamp, service = nil)
         #   Returns the the item's state at the given time
         #   @param [#to_zoned_date_time] timestamp The point in time at which to search
         #   @param [Symbol, String] service An optional persistence id instead of the default persistence service.
-        #   @return [HistoricState, nil] The item's state at `timestamp`,
+        #   @return [PersistedState, nil] The item's state at `timestamp`,
         #     or nil if no previous state could be found.
+        #   @deprecated In openHAB 4.2, use {#persisted_state} instead
+
+        # @!method persisted_state(timestamp, service = nil)
+        #   Returns the the item's state at the given time
+        #   @param [#to_zoned_date_time] timestamp The point in time at which to search
+        #   @param [Symbol, String] service An optional persistence id instead of the default persistence service.
+        #   @return [PersistedState, nil] The item's state at `timestamp`,
+        #     or nil if no state could be found.
+        #   @since openHAB 4.2
 
         # @!method maximum_since(timestamp, service = nil)
         #   Returns the maximum value of the item's state since the given time
         #   @param [#to_zoned_date_time] timestamp The point in time from which to search
         #   @param [Symbol, String] service An optional persistence id instead of the default persistence service.
-        #   @return [HistoricState, nil] The maximum value since `timestamp`,
-        #     or nil if no previous state could be found.
+        #   @return [PersistedState, nil] The maximum value since `timestamp`,
+        #     or nil if no previous states could be found.
+
+        # @!method maximum_until(timestamp, service = nil)
+        #   Returns the maximum value of the item's state between now until the given time
+        #   @param [#to_zoned_date_time] timestamp The point in time until which to search
+        #   @param [Symbol, String] service An optional persistence id instead of the default persistence service.
+        #   @return [PersistedState, nil] The maximum value until `timestamp`,
+        #     or nil if no future states could be found.
+        #   @since openHAB 4.2
 
         # @!method maximum_between(start, finish, service = nil)
         #   Returns the maximum value of the item's state between two points in time
         #   @param [#to_zoned_date_time] start The point in time from which to search
         #   @param [#to_zoned_date_time] finish The point in time to which to search
         #   @param [Symbol, String] service An optional persistence id instead of the default persistence service.
-        #   @return [HistoricState, nil] The maximum value between `start` and `finish`,
-        #     or nil if no previous state could be found.
+        #   @return [PersistedState, nil] The maximum value between `start` and `finish`,
+        #     or nil if no states could be found.
 
         # @!method minimum_since(timestamp, service = nil)
         #   Returns the minimum value of the item's state since the given time
         #   @param [#to_zoned_date_time] timestamp The point in time from which to search
         #   @param [Symbol, String] service An optional persistence id instead of the default persistence service.
-        #   @return [HistoricState, nil] The minimum value since `timestamp`,
-        #     or nil if no previous state could be found.
+        #   @return [PersistedState, nil] The minimum value since `timestamp`,
+        #     or nil if no previous states could be found.
+
+        # @!method minimum_until(timestamp, service = nil)
+        #   Returns the minimum value of the item's state between now until the given time
+        #   @param [#to_zoned_date_time] timestamp The point in time until which to search
+        #   @param [Symbol, String] service An optional persistence id instead of the default persistence service.
+        #   @return [PersistedState, nil] The minimum value until `timestamp`,
+        #     or nil if no future states could be found.
+        #   @since openHAB 4.2
 
         # @!method minimum_between(start, finish, service = nil)
         #   Returns the minimum value of the item's state between two points in time
         #   @param [#to_zoned_date_time] start The point in time from which to search
         #   @param [#to_zoned_date_time] finish The point in time to which to search
         #   @param [Symbol, String] service An optional persistence id instead of the default persistence service.
-        #   @return [HistoricState, nil] The minimum value between `start` and `finish`,
-        #     or nil if no previous state could be found.
+        #   @return [PersistedState, nil] The minimum value between `start` and `finish`,
+        #     or nil if no states could be found.
 
         # @!method updated_since?(timestamp, service = nil)
         #   Whether the item's state has been updated since the given time
@@ -247,6 +320,13 @@ module OpenHAB
         #   @param [Symbol, String] service An optional persistence id instead of the default persistence service.
         #   @return [true,false] True if the item's state has been updated since the given `timestamp`, False otherwise.
 
+        # @!method updated_until?(timestamp, service = nil)
+        #   Whether the item's state will be updated between now until the given time
+        #   @param [#to_zoned_date_time] timestamp The point in time until which to search
+        #   @param [Symbol, String] service An optional persistence id instead of the default persistence service.
+        #   @return [true,false] True if the item's state will be updated until the given `timestamp`, False otherwise.
+        #   @since openHAB 4.2
+
         # @!method updated_between?(start, finish, service = nil)
         #   Whether the item's state was updated between two points in time
         #   @param [#to_zoned_date_time] start The point in time from which to search
@@ -260,8 +340,15 @@ module OpenHAB
         #   @param [Symbol, String] service An optional persistence id instead of the default persistence service.
         #   @return [Integer] The number of values persisted for this item.
 
+        # @!method count_until(timestamp, service = nil)
+        #   Returns the number of available data points between now until the given time.
+        #   @param [#to_zoned_date_time] timestamp The point in time until which to search
+        #   @param [Symbol, String] service An optional persistence id instead of the default persistence service.
+        #   @return [Integer] The number of values persisted for this item.
+        #   @since openHAB 4.2
+
         # @!method count_between(start, finish, service = nil)
-        #   Returns the number of available historic data points between two points in time.
+        #   Returns the number of available data points between two points in time.
         #   @param [#to_zoned_date_time] start The point in time from which to search
         #   @param [#to_zoned_date_time] finish The point in time to which to search
         #   @param [Symbol, String] service An optional persistence id instead of the default persistence service.
@@ -273,83 +360,293 @@ module OpenHAB
         #   @param [Symbol, String] service An optional persistence id instead of the default persistence service.
         #   @return [Integer] The number of values persisted for this item.
 
+        # @!method count_state_changes_until(timestamp, service = nil)
+        #   Returns the number of changes in data points between now until the given time.
+        #   @param [#to_zoned_date_time] timestamp The point in time until which to search
+        #   @param [Symbol, String] service An optional persistence id instead of the default persistence service.
+        #   @return [Integer] The number of values persisted for this item.
+        #   @since openHAB 4.2
+
         # @!method count_state_changes_between(start, finish, service = nil)
-        #   Returns the number of changes in historic data points between two points in time.
+        #   Returns the number of changes in data points between two points in time.
         #   @param [#to_zoned_date_time] start The point in time from which to search
         #   @param [#to_zoned_date_time] finish The point in time to which to search
         #   @param [Symbol, String] service An optional persistence id instead of the default persistence service.
         #   @return [Integer] The number of values persisted for this item.
 
         # @!method all_states_since(timestamp, service = nil)
-        #   @since openHAB 4.0
         #   Returns all the states from a point in time until now.
         #   @param [#to_zoned_date_time] timestamp The point in time from which to search
         #   @param [Symbol, String] service An optional persistence id instead of the default persistence service.
-        #   @return [Array<HistoricState>] An array of {HistoricState} persisted for this item.
+        #   @return [Array<PersistedState>] An array of {PersistedState} persisted for this item.
+        #   @since openHAB 4.0
+
+        # @!method all_states_until(timestamp, service = nil)
+        #   Returns all the states between now until the given time.
+        #   @param [#to_zoned_date_time] timestamp The point in time until which to search
+        #   @param [Symbol, String] service An optional persistence id instead of the default persistence service.
+        #   @return [Array<PersistedState>] An array of {PersistedState} persisted for this item.
+        #   @since openHAB 4.2
 
         # @!method all_states_between(start, finish, service = nil)
-        #   @since openHAB 4.0
         #   Returns all the states between two points in time.
         #   @param [#to_zoned_date_time] start The point in time from which to search
         #   @param [#to_zoned_date_time] finish The point in time to which to search
         #   @param [Symbol, String] service An optional persistence id instead of the default persistence service.
-        #   @return [Array<HistoricState>] An array of {HistoricState} persisted for this item.
+        #   @return [Array<PersistedState>] An array of {PersistedState} persisted for this item.
+        #   @since openHAB 4.0
+
+        # @!method remove_all_states_since(timestamp, service = nil)
+        #   Removes persisted data points since a certain point in time.
+        #   @param [#to_zoned_date_time] timestamp The point in time from which to remove
+        #   @param [Symbol, String] service An optional persistence id instead of the default persistence service.
+        #   @return [void]
+        #   @since openHAB 4.2
+
+        # @!method remove_all_states_until(timestamp, service = nil)
+        #   Removes persisted data points from now until the given point in time.
+        #   @param [#to_zoned_date_time] timestamp The point in time until which to remove
+        #   @param [Symbol, String] service An optional persistence id instead of the default persistence service.
+        #   @return [void]
+        #   @since openHAB 4.2
+
+        # @!method remove_all_states_between(start, finish, service = nil)
+        #   Removes persisted data points between two points in time.
+        #   @param [#to_zoned_date_time] start The point in time from which to remove
+        #   @param [#to_zoned_date_time] finish The point in time to which to remove
+        #   @param [Symbol, String] service An optional persistence id instead of the default persistence service.
+        #   @return [void]
+        #   @since openHAB 4.2
+
+        #
+        # Persist item state to the persistence service
+        #
+        # @overload persist(service = nil)
+        #   Persists the current state of the item
+        #   @param [Symbol, String] service An optional persistence id instead of the default persistence service.
+        #   @return [void]
+        #
+        # @overload persist(timestamp, state, service = nil)
+        #   Persists a state at a given timestamp
+        #   @param [#to_zoned_date_time] timestamp The timestamp for the given state to be stored
+        #   @param [Types::State] state The state to be stored
+        #   @param [Symbol, String] service An optional persistence id instead of the default persistence service.
+        #   @return [void]
+        #   @since openHAB 4.2
+        #
+        # @overload persist(time_series, service = nil)
+        #   Persists a time series
+        #   @param [Types::TimeSeries] time_series The time series of states to be stored
+        #   @param [Symbol, String] service An optional persistence id instead of the default persistence service.
+        #   @return [void]
+        #   @since openHAB 4.2
+        #
+        def persist(*args)
+          # @deprecated OH 4.1 this if block content can be removed when dropping OH 4.1 support
+          if Core.version < Core::V4_2
+            raise ArgumentError, "wrong number of arguments (given #{args.size}, expected 0..1)" if args.size > 1
+
+            service = args.last || persistence_service
+            Actions::PersistenceExtensions.persist(self, service&.to_s)
+            return
+          end
+
+          first_arg = args.first
+          if first_arg.is_a?(TimeSeries)
+            if args.size > 2
+              raise ArgumentError,
+                    "wrong number of arguments to persist a time series (given #{args.size}, expected 1..2)"
+            end
+
+            service = args[1] || persistence_service
+            Actions::PersistenceExtensions.java_send :persist,
+                                                     [Item.java_class, Types::TimeSeries.java_class, java.lang.String],
+                                                     self,
+                                                     first_arg,
+                                                     service&.to_s
+          elsif first_arg.respond_to?(:to_zoned_date_time)
+            unless args.size.between?(2, 3)
+              raise ArgumentError, "wrong number of arguments to persist a state (given #{args.size}, expected 2..3)"
+            end
+
+            timestamp = first_arg.to_zoned_date_time
+            state = format_update(args[1])
+            service = args[2] || persistence_service
+            Actions::PersistenceExtensions.java_send :persist,
+                                                     [Item.java_class,
+                                                      ZonedDateTime.java_class,
+                                                      org.openhab.core.types.State,
+                                                      java.lang.String],
+                                                     self,
+                                                     timestamp,
+                                                     state,
+                                                     service&.to_s
+
+          else
+            if args.size > 1
+              raise ArgumentError,
+                    "wrong number of arguments to persist the current state (given #{args.size}, expected 0..1)"
+            end
+            service = first_arg || persistence_service
+            Actions::PersistenceExtensions.java_send :persist,
+                                                     [Item.java_class, java.lang.String],
+                                                     self,
+                                                     service&.to_s
 
-        %i[persist last_update].each do |method|
-          define_method(method) do |service = nil|
-            service ||= persistence_service
-            Actions::PersistenceExtensions.public_send(method, self, service&.to_s)
           end
         end
 
+        # @!method last_update(service = nil)
+        #   Returns the time the item was last updated.
+        #   @param [Symbol, String] service An optional persistence id instead of the default persistence service.
+        #   @return [ZonedDateTime, nil] The timestamp of the last update
+
+        # @!method next_update(service = nil)
+        #   Returns the first future update time of the item.
+        #   @param [Symbol, String] service An optional persistence id instead of the default persistence service.
+        #   @return [ZonedDateTime, nil] The timestamp of the next update
+        #   @see last_update
+        #   @since openHAB 4.2
+
+        %i[last_update next_update].each do |method|
+          # @deprecated OH 4.1 remove this guard when dropping OH 4.1
+          next unless Actions::PersistenceExtensions.respond_to?(method)
+
+          class_eval <<~RUBY, __FILE__, __LINE__ + 1
+            def #{method}(service = nil)                            # def last_update(service = nil)
+              service ||= persistence_service                       #   service ||= persistence_service
+              result = Actions::PersistenceExtensions.#{method}(    #   result = Actions::PersistenceExtensions.last_update(
+                self,                                               #     self,
+                service&.to_s                                       #     service&.to_s
+              )                                                     #   )
+              wrap_result(result)                                   #   wrap_result(result)
+            end                                                     # end
+          RUBY
+        end
+
+        # @!method previous_state(service = nil, skip_equal: false)
+        #   Return the previous state of the item
+        #
+        #   @param skip_equal [true,false] if true, skips equal state values and
+        #          searches the first state not equal the current state
+        #   @param service [String] the name of the PersistenceService to use
         #
-        # Return the previous state of the item
+        #   @return [PersistedState, nil] the previous state or nil if no previous state could be found,
+        #           or if the default persistence service is not configured or
+        #           does not refer to a valid service
+
+        # @!method next_state(service = nil, skip_equal: false)
+        #   Return the next state of the item
         #
-        # @param skip_equal [true,false] if true, skips equal state values and
-        #        searches the first state not equal the current state
-        # @param service [String] the name of the PersistenceService to use
+        #   @param skip_equal [true,false] if true, skips equal state values and
+        #          searches the first state not equal the current state
+        #   @param service [String] the name of the PersistenceService to use
         #
-        # @return [HistoricState, nil] the previous state or nil if no previous state could be found,
-        #         or if the default persistence service is not configured or
-        #         does not refer to a valid service
+        #   @return [PersistedState, nil] the previous state or nil if no previous state could be found,
+        #           or if the default persistence service is not configured or
+        #           does not refer to a valid service
         #
-        def previous_state(service = nil, skip_equal: false)
-          service ||= persistence_service
-          result = Actions::PersistenceExtensions.previous_state(self, skip_equal, service&.to_s)
-          HistoricState.new(quantify(result.state), result) if result
+        #   @since openHAB 4.2
+
+        %i[previous_state next_state].each do |method|
+          # @deprecated OH 4.1 remove this guard when dropping OH 4.1
+          next unless Actions::PersistenceExtensions.respond_to?(method)
+
+          class_eval <<~RUBY, __FILE__, __LINE__ + 1
+            def #{method}(service = nil, skip_equal: false)       # def previous_state(service = nil, skip_equal: false)
+              service ||= persistence_service                     #   service ||= persistence_service
+              result = Actions::PersistenceExtensions.#{method}(  #   result = Actions::PersistenceExtensions.previous_state(
+                self,                                             #     self,
+                skip_equal,                                       #     skip_equal,
+                service&.to_s                                     #     service&.to_s
+              )                                                   #   )
+              wrap_result(result, quantify: true)                 #   wrap_result(result, quantify: true)
+            end                                                   # end
+          RUBY
         end
 
-        PERSISTENCE_METHODS.each do |method|
-          define_method(method) do |timestamp, service = nil|
-            service ||= persistence_service
-            result = Actions::PersistenceExtensions.public_send(
-              method.to_s.delete_suffix("?"),
-              self,
-              timestamp.to_zoned_date_time,
-              service&.to_s
-            )
-            wrap_result(result, method)
+        class << self
+          # @!visibility private
+          def def_persistence_method(method, quantify: false)
+            method = method.to_s.dup
+            suffix = method.delete_suffix!("?") && "?"
+
+            class_eval <<~RUBY, __FILE__, __LINE__ + 1
+              def #{method}#{suffix}(timestamp, service = nil)        # def changed_since?(timestamp, service = nil)
+                service ||= persistence_service                       #   service ||= persistence_service
+                result = Actions::PersistenceExtensions.#{method}(    #   result = Actions::PersistenceExtensions.changed_since(
+                  self,                                               #     self,
+                  timestamp.to_zoned_date_time,                       #     timestamp.to_zoned_date_time,
+                  service&.to_s                                       #     service&.to_s
+                )                                                     #   )
+                wrap_result(result, quantify: #{quantify})            #   wrap_result(result, quantify: false)
+              end                                                     # end
+            RUBY
           end
 
-          next unless /_since\??$/.match?(method.to_s)
+          # @!visibility private
+          def def_persistence_methods(method, quantify: false)
+            method = method.to_s.dup
+            suffix = method.delete_suffix!("?") && "?"
 
-          between_method = method.to_s.sub("_since", "_between").to_sym
-          define_method(between_method) do |start, finish, service = nil|
-            service ||= persistence_service
-            result = Actions::PersistenceExtensions.public_send(
-              between_method.to_s.delete_suffix("?"),
-              self,
-              start.to_zoned_date_time,
-              finish.to_zoned_date_time,
-              service&.to_s
-            )
-            wrap_result(result, method)
+            def_persistence_method("#{method}_since#{suffix}", quantify: quantify)
+            # @deprecated OH 4.1 remove if guard, keeping the content, when dropping OH 4.1
+            if OpenHAB::Core.version >= OpenHAB::Core::V4_2
+              def_persistence_method("#{method}_until#{suffix}", quantify: quantify)
+            end
+
+            method = "#{method}_between"
+            class_eval <<~RUBY, __FILE__, __LINE__ + 1
+              def #{method}#{suffix}(start, finish, service = nil)    # def changed_between?(start, finish, service = nil)
+                service ||= persistence_service                       #   service ||= persistence_service
+                result = Actions::PersistenceExtensions.#{method}(    #   result = Actions::PersistenceExtensions.changed_between?(
+                  self,                                               #     self,
+                  start.to_zoned_date_time,                           #     start.to_zoned_date_time,
+                  finish.to_zoned_date_time,                          #     finish.to_zoned_date_time,
+                  service&.to_s                                       #     service&.to_s
+                )                                                     #   )
+                wrap_result(result, quantify: #{quantify})            #   wrap_result(result, quantify: false)
+              end                                                     # end
+            RUBY
           end
         end
 
-        # evolution_rate's "between" method is overloaded with the same name
-        method = :evolution_rate
-        define_method(method) do |start, finish_or_service = nil, service = nil|
+        def_persistence_methods(:average, quantify: true)
+        def_persistence_methods(:delta, quantify: true)
+        def_persistence_methods(:deviation, quantify: true)
+        def_persistence_methods(:sum, quantify: true)
+        def_persistence_methods(:variance, quantify: true)
+
+        def_persistence_methods(:changed?)
+        def_persistence_methods(:count)
+        def_persistence_methods(:count_state_changes)
+        alias_method :state_changes_since, :count_state_changes_since
+        alias_method :state_changes_until, :count_state_changes_until if OpenHAB::Core.version >= OpenHAB::Core::V4_2
+        alias_method :state_changes_between, :count_state_changes_between
+
+        # @deprecated OH 4.2 - this still exists in OH 4.2 but logs a deprecation warning
+        def_persistence_method(:historic_state, quantify: true)
+
+        def_persistence_methods(:maximum, quantify: true)
+        def_persistence_methods(:minimum, quantify: true)
+        def_persistence_methods(:updated?)
+
+        if OpenHAB::Core.version >= OpenHAB::Core::V4_0
+          def_persistence_methods(:get_all_states, quantify: true)
+          alias_method :all_states_since, :get_all_states_since
+          alias_method :all_states_until, :get_all_states_until if OpenHAB::Core.version >= OpenHAB::Core::V4_2
+          alias_method :all_states_between, :get_all_states_between
+        end
+
+        if OpenHAB::Core.version >= OpenHAB::Core::V4_2
+          def_persistence_method(:persisted_state) # already quantified in core
+
+          def_persistence_methods(:evolution_rate)
+          def_persistence_methods(:remove_all_states)
+        end
+
+        # @deprecated OH 4.2 this method is deprecated in OH 4.2 and may be removed in a future version
+        def evolution_rate(start, finish_or_service = nil, service = nil)
           if service.nil?
             if finish_or_service.respond_to?(:to_zoned_date_time)
               service = persistence_service
@@ -362,31 +659,20 @@ module OpenHAB
             finish = finish_or_service
           end
 
-          result = if finish
-                     Actions::PersistenceExtensions.public_send(
-                       method,
-                       self,
-                       start.to_zoned_date_time,
-                       finish.to_zoned_date_time,
-                       service&.to_s
-                     )
-                   else
-                     Actions::PersistenceExtensions.public_send(
-                       method,
-                       self,
-                       start.to_zoned_date_time,
-                       service&.to_s
-                     )
-                   end
-          wrap_result(result, method)
-        end
-
-        alias_method :state_changes_since, :count_state_changes_since
-        alias_method :state_changes_between, :count_state_changes_between
-        # @deprecated OH 3.4 - if guard is unnecessary in OH4
-        if OpenHAB::Core.version >= OpenHAB::Core::V4_0
-          alias_method :all_states_since, :get_all_states_since
-          alias_method :all_states_between, :get_all_states_between
+          if finish
+            Actions::PersistenceExtensions.evolution_rate(
+              self,
+              start.to_zoned_date_time,
+              finish.to_zoned_date_time,
+              service&.to_s
+            )
+          else
+            Actions::PersistenceExtensions.java_send :evolutionRate,
+                                                     [Item.java_class, ZonedDateTime.java_class, java.lang.String],
+                                                     self,
+                                                     start.to_zoned_date_time,
+                                                     service&.to_s
+          end
         end
 
         private
@@ -398,9 +684,10 @@ module OpenHAB
         #
         # @return [Object] QuantityType or the original value
         #
+        # @deprecated OH 4.1 in OH4.2, quantify is no longer needed because it is done inside core
         def quantify(value)
           if value.is_a?(DecimalType) && respond_to?(:unit) && unit
-            logger.trace("Unitizing #{value} with unit #{unit}")
+            logger.trace { "Unitizing #{value} with unit #{unit}" }
             QuantityType.new(value.to_big_decimal, unit)
           else
             value
@@ -411,23 +698,23 @@ module OpenHAB
         # Wrap the result into a more convenient object type depending on the method and result.
         #
         # @param [Object] result the raw result type to be wrapped
-        # @param [Symbol] method the name of the called method
+        # @param [true, false] quantify whether to quantify the result
         #
-        # @return [HistoricState] a {HistoricState} object if the result was a HistoricItem
+        # @return [PersistedState] a {PersistedState} object if the result was a HistoricItem
+        # @return [Array<PersistedState>] an array of {PersistedState} objects if the result was an array
+        #   of HistoricItem
         # @return [QuantityType] a `QuantityType` object if the result was an average, delta, deviation,
-        #                        sum, or variance.
-        # @return [Array<HistoricState>] an array of {HistoricState} objects if the result was an array
-        #                        of HistoricItem
+        #   sum, or variance.
         # @return [Object] the original result object otherwise.
         #
-        def wrap_result(result, method)
+        def wrap_result(result, quantify: false)
           case result
           when org.openhab.core.persistence.HistoricItem
-            HistoricState.new(quantify(result.state), result)
+            PersistedState.new(result, quantify ? quantify(result.state) : nil)
           when java.util.Collection, Array
-            result.to_a.map { |historic_item| wrap_result(historic_item, method) }
+            result.to_a.map { |historic_item| wrap_result(historic_item, quantify: quantify) }
           else
-            return quantify(result) if QUANTITY_METHODS.include?(method)
+            return quantify(result) if quantify
 
             result
           end

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

@@ -57,6 +57,126 @@ module OpenHAB
           uid.to_s
         end
 
+        # @!attribute item_name [r]
+        # Return the name of the item this channel is linked to. If a channel is linked to more than one item,
+        # this method only returns the first item.
+        #
+        # @return [String, nil]
+        def item_name
+          item_names.first
+        end
+
+        # @!attribute item_names [r]
+        # Return the names of all of the items this channel is linked to.
+        #
+        # @return [Array<String>]
+        def item_names
+          Things::Links::Provider.registry.get_linked_item_names(uid)
+        end
+
+        # @!attribute item [r]
+        # Return the item this channel is linked to. If a channel is linked to more than one item,
+        # this method only returns the first item.
+        #
+        # @return [Items::Item, nil]
+        def item
+          items.first
+        end
+
+        # @!attribute items [r]
+        # Return all of the items this channel is linked to.
+        #
+        # @return [Array<Items::Item>]
+        def items
+          Things::Links::Provider.registry.get_linked_items(uid).map { |item| Items::Proxy.new(item) }
+        end
+
+        #
+        # @!attribute links [r]
+        # Returns all of the channel's links (items and link configurations).
+        #
+        # @return [Items::ItemChannelLinks] An array of ItemChannelLink or an empty array
+        #
+        # @example Get the configuration of the first link
+        #   things["mqtt:topic:livingroom-light"].channel["power"].links.first.configuration
+        #
+        # @example Remove all managed links
+        #   things["mqtt:topic:livingroom-light"].channel["power"].links.clear
+        #
+        # @see link
+        # @see unlink
+        #
+        def links
+          Items::ItemChannelLinks.new(uid, Things::Links::Provider.registry.get_links(uid))
+        end
+
+        #
+        # @return [ItemChannelLink, nil]
+        #
+        # @overload link
+        #   Returns the channel's link. If an channel is linked to more than one item,
+        #   this method only returns the first link.
+        #
+        #   @return [Things::ItemChannelLink, nil]
+        #
+        # @overload link(item, config = {})
+        #
+        #   Links the channel to an item.
+        #
+        #   @param [String, Items::Item] channel The channel to link to.
+        #   @param [Hash] config The configuration for the link.
+        #
+        #   @return [Things::ItemChannelLink] The created link.
+        #
+        #   @example Link a channel to an item
+        #     things["mqtt:topic:livingroom-light"].channels["power"].link(LivingRoom_Light_Power)
+        #
+        #   @example Specify a link configuration
+        #     things["mqtt:topic:outdoor-thermometer"].channels["temperature"].link(
+        #       High_Temperature_Alert,
+        #       profile: "system:hysteresis",
+        #       lower: "29 °C",
+        #       upper: "30 °C")
+        #
+        #   @see links
+        #   @see unlink
+        #
+        def link(item = nil, config = nil)
+          return Things::Links::Provider.registry.get_links(uid).first if item.nil? && config.nil?
+
+          config ||= {}
+          Core::Things::Links::Provider.create_link(item, self, config).tap do |new_link|
+            provider = Core::Things::Links::Provider.current
+            if !(current_link = provider.get(new_link.uid))
+              provider.add(new_link)
+            elsif current_link.configuration != config
+              provider.update(new_link)
+            end
+          end
+        end
+
+        #
+        # Removes a link to an item from managed link providers.
+        #
+        # @param [String, Items::Item] item The item to remove the link to.
+        #
+        # @return [Things::ItemChannelLink, nil] The removed link, if found.
+        # @raise [FrozenError] if the link is not managed by a managed link provider.
+        #
+        # @see link
+        # @see links
+        #
+        def unlink(item)
+          link_to_delete = Things::Links::Provider.create_link(item, self, {})
+          provider = Things::Links::Provider.registry.provider_for(link_to_delete.uid)
+          unless provider.is_a?(ManagedProvider)
+            raise FrozenError,
+                  "Cannot remove the link #{link_to_delete.uid} from non-managed provider #{provider.inspect}"
+          end
+
+          provider.remove(link_to_delete.uid)
+        end
+
         # @deprecated OH3.4 this whole section is not needed in OH4+. Also see Thing#config_eql?
         if Core.version < Core::V4_0
           # @!visibility private

data/lib/openhab/core/things/links/provider.rb

@@ -28,7 +28,8 @@ module OpenHAB
               config = Configuration.new(config.transform_keys(&:to_s))
               channel = ChannelUID.new(channel) if channel.is_a?(String)
               channel = channel.uid if channel.is_a?(Channel)
-              org.openhab.core.thing.link.ItemChannelLink.new(item.name, channel, config)
+              item = item.name if item.is_a?(Item)
+              org.openhab.core.thing.link.ItemChannelLink.new(item, channel, config)
             end
           end
 

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

@@ -992,9 +992,14 @@ module OpenHAB
         #
         # Creates a channel linked trigger
         #
+        # @param [Item, String, nil] item The item to create a trigger for. If nil, all items are matched.
+        # @param [Core::Things::Channel, Core::Things::ChannelUID, String, nil] channel
+        #   The channel to create a trigger for. If nil, all channels are matched.
         # @param [Object] attach object to be attached to the trigger
         # @return [void]
         #
+        # @since openHAB 4.0 Support for filtering with item and channel was added
+        #
         # @example
         #    rule "channel linked" do
         #      channel_linked
@@ -1002,9 +1007,10 @@ module OpenHAB
         #        logger.info("#{event.link.item.name} linked to #{event.link.channel_uid}.")
         #      end
         #    end
-        def channel_linked(attach: nil)
-          @ruby_triggers << [:channel_linked]
-          event("openhab/links/*/added", types: "ItemChannelLinkAddedEvent", attach: attach)
+        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)
         end
 
         #
@@ -1013,9 +1019,14 @@ module OpenHAB
         # Note that the item or the thing it's linked to may no longer exist,
         # so if you try to access those objects they'll be nil.
         #
+        # @param [Item, String, nil] item The item to create a trigger for. If nil, all items are matched.
+        # @param [Core::Things::Channel, Core::Things::ChannelUID, String, nil] channel
+        #   The channel to create a trigger for. If nil, all channels are matched.
         # @param [Object] attach object to be attached to the trigger
         # @return [void]
         #
+        # @since openHAB 4.0 Support for filtering with item and channel was added
+        #
         # @example
         #    rule "channel unlinked" do
         #      channel_unlinked
@@ -1023,9 +1034,10 @@ module OpenHAB
         #        logger.info("#{event.link.item_name} unlinked from #{event.link.channel_uid}.")
         #      end
         #    end
-        def channel_unlinked(attach: nil)
-          @ruby_triggers << [:channel_linked]
-          event("openhab/links/*/removed", types: "ItemChannelLinkRemovedEvent", attach: attach)
+        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)
         end
 
         #
@@ -1556,9 +1568,12 @@ module OpenHAB
         #
         # Creates an item added trigger
         #
+        # @param [String, nil] pattern The pattern to match items against
         # @param [Object] attach object to be attached to the trigger
         # @return [void]
         #
+        # @since openHAB 4.0 Support for pattern filter was added
+        #
         # @example
         #    rule "item added" do
         #      item_added
@@ -1566,17 +1581,20 @@ module OpenHAB
         #        logger.info("#{event.item.name} added.")
         #      end
         #    end
-        def item_added(attach: nil)
-          @ruby_triggers << [:item_added]
-          event("openhab/items/*/added", types: "ItemAddedEvent", attach: attach)
+        def item_added(pattern = "*", attach: nil)
+          @ruby_triggers << [:item_added, pattern]
+          event("openhab/items/#{pattern}/added", types: "ItemAddedEvent", attach: attach)
         end
 
         #
         # Creates an item removed trigger
         #
+        # @param [String, nil] pattern The pattern to match items against
         # @param [Object] attach object to be attached to the trigger
         # @return [void]
         #
+        # @since openHAB 4.0 Support for pattern filter was added
+        #
         # @example
         #    rule "item removed" do
         #      item_removed
@@ -1584,14 +1602,15 @@ module OpenHAB
         #        logger.info("#{event.item.name} removed.")
         #      end
         #    end
-        def item_removed(attach: nil)
-          @ruby_triggers << [:item_removed]
-          event("openhab/items/*/removed", types: "ItemRemovedEvent", attach: attach)
+        def item_removed(pattern = "*", attach: nil)
+          @ruby_triggers << [:item_removed, pattern]
+          event("openhab/items/#{pattern}/removed", types: "ItemRemovedEvent", attach: attach)
         end
 
         #
         # Creates an item updated trigger
         #
+        # @param [String, nil] pattern The pattern to match items against
         # @param [Object] attach object to be attached to the trigger
         # @return [void]
         #
@@ -1603,17 +1622,20 @@ module OpenHAB
         #     end
         #   end
         #
-        def item_updated(attach: nil)
-          @ruby_triggers << [:item_updated]
-          event("openhab/items/*/updated", types: "ItemUpdatedEvent", attach: attach)
+        def item_updated(pattern = "*", attach: nil)
+          @ruby_triggers << [:item_updated, pattern]
+          event("openhab/items/#{pattern}/updated", types: "ItemUpdatedEvent", attach: attach)
         end
 
         #
         # Creates a thing added trigger
         #
+        # @param [String, nil] pattern The pattern to match things against
         # @param [Object] attach object to be attached to the trigger
         # @return [void]
         #
+        # @since openHAB 4.0 Support for pattern filter was added
+        #
         # @example
         #    rule "thing added" do
         #      thing_added
@@ -1621,17 +1643,20 @@ module OpenHAB
         #        logger.info("#{event.thing.uid} added.")
         #      end
         #    end
-        def thing_added(attach: nil)
-          @ruby_triggers << [:thing_added]
-          event("openhab/things/*/added", types: "ThingAddedEvent", attach: attach)
+        def thing_added(pattern = "*", attach: nil)
+          @ruby_triggers << [:thing_added, pattern]
+          event("openhab/things/#{pattern}/added", types: "ThingAddedEvent", attach: attach)
         end
 
         #
         # Creates a thing removed trigger
         #
+        # @param [String, nil] pattern The pattern to match things against
         # @param [Object] attach object to be attached to the trigger
         # @return [void]
         #
+        # @since openHAB 4.0 Support for pattern filter was added
+        #
         # @example
         #    rule "thing removed" do
         #      thing_removed
@@ -1639,17 +1664,20 @@ module OpenHAB
         #        logger.info("#{event.thing.uid} removed.")
         #      end
         #    end
-        def thing_removed(attach: nil)
-          @ruby_triggers << [:thing_removed]
-          event("openhab/things/*/removed", types: "ThingRemovedEvent", attach: attach)
+        def thing_removed(pattern = "*", attach: nil)
+          @ruby_triggers << [:thing_removed, pattern]
+          event("openhab/things/#{pattern}/removed", types: "ThingRemovedEvent", attach: attach)
         end
 
         #
         # Creates a thing updated trigger
         #
+        # @param [String, nil] pattern The pattern to match things against
         # @param [Object] attach object to be attached to the trigger
         # @return [void]
         #
+        # @since openHAB 4.0 Support for pattern filter was added
+        #
         # @example
         #   rule "thing updated" do
         #     thing_updated
@@ -1658,9 +1686,9 @@ module OpenHAB
         #     end
         #   end
         #
-        def thing_updated(attach: nil)
-          @ruby_triggers << [:thing_updated]
-          event("openhab/things/*/updated", types: "ThingUpdatedEvent", attach: attach)
+        def thing_updated(pattern = "*", attach: nil)
+          @ruby_triggers << [:thing_updated, pattern]
+          event("openhab/things/#{pattern}/updated", types: "ThingUpdatedEvent", attach: attach)
         end
 
         #

data/lib/openhab/dsl/version.rb

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

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

@@ -28,7 +28,7 @@ module OpenHAB
           end
         end
 
-        module HistoricState
+        module PersistedState
           def timestamp
             # PersistenceExtensions uses an anonymous class to wrap the current
             # state if that happens to be an answer. Except it calls
@@ -41,7 +41,7 @@ module OpenHAB
             super
           end
         end
-        Core::Items::Persistence::HistoricState.prepend(HistoricState)
+        Core::Items::Persistence::PersistedState.prepend(PersistedState)
 
         attr_reader :id
 
@@ -54,14 +54,18 @@ module OpenHAB
           @data = Hash.new { |h, k| h[k] = [] }
         end
 
-        def store(item, date = nil, state = nil)
-          date = nil if date.is_a?(String) # alias overload
+        def store(item, date = nil, state = nil, item_alias = nil)
+          if date.is_a?(String) # alias overload
+            item_alias = date
+            date = nil
+          end
           state ||= item.state
           date ||= ZonedDateTime.now
+          item_alias ||= item.name
 
           new_item = HistoricItem.new(date, state, item.name)
 
-          item_history = @data[item.name]
+          item_history = @data[item_alias]
 
           insert_index = item_history.bsearch_index do |i|
             i.timestamp.compare_to(date).positive?
@@ -79,6 +83,7 @@ module OpenHAB
             historic_item = item_history.delete_at(index)
             @data.delete(historic_item.name) if item_history.empty?
           end
+          true
         end
 
         def query(filter)

metadata

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