openhab-scripting 5.38.5 → 5.39.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f837c043c0b58d688830c0cc06c0c681fb2bc3337cb2339735698e8b32cb22db
-  data.tar.gz: 7fc34b3422e4bbf599175431297ac35bf8342c333d1a79b9c331d73fb5d1d816
+  metadata.gz: 42bb17850e8b9ed0e6c1d585eb4484d8aa32cd4d7606d6a33e92da33c8f25495
+  data.tar.gz: ceedee653482dffbd6612808f2707639d162e5b15113fc882b3c0e27785375d6
 SHA512:
-  metadata.gz: e36b375d4ecc8ec2ba59b5c154d1ca037d61c6bb9a2fdce9a7084038bf62e3cccdf1173fb9768f0015e07afa0ee9ec0b0ac92839be98ea750ce752862d9a7fc8
-  data.tar.gz: 0beef971e272145cc43dbdedc62f07dce8ac3e5e6fba37d8fbee4eda8fe26d73f246c1338607de007db6196e73488ed1778099bbe119282cf5c33ce5f3c7a151
+  metadata.gz: 3c6ee7006beb70981412855a33d503a8eb93d79418cba0838f2424b514725754522c02e35ab170484beb724bb8c5bb26f750c62d8b739bac645bb4e43685b2f2
+  data.tar.gz: 337b1069f2e153acb498fdcf4ec7ffa359197b88b9fc1c3075d24cc1ec1ba83bd4269ff741b442c7dad1c8b5b8bb6a6dcffddf85af35af511efcd2a860e2a92b

data/lib/openhab/console/stdio.rb

@@ -23,7 +23,7 @@ module OpenHAB
       end
 
       def winsize
-        [@terminal.width, @terminal.height]
+        [@terminal.height, @terminal.width]
       end
 
       def inspect

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

@@ -132,15 +132,25 @@ module OpenHAB
         #   @since openHAB 4.2
         #   @since openHAB 5.0 riemann_type parameter added
 
-        # @!method average_between(start, finish, service = nil, riemann_type: nil)
+        # @!method average_between
         #   Returns the average 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.
-        #   @param [:left, :midpoint, :right, :trapezoidal] riemann_type An optional approximation type for Riemann sum.
-        #     If nil, :left is used.
+        #
+        #   @overload average_between(start, finish, service = nil, reimann_type: nil)
+        #     @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.
+        #     @param [:left, :midpoint, :right, :trapezoidal] riemann_type An optional approximation type for Riemann
+        #       sum. If nil, :left is used.
+        #
+        #   @overload average_between(range, service = nil, reimann_type: nil)
+        #     @param [Range<#to_zoned_date_time>] range The time range to search
+        #     @param [Symbol, String] service An optional persistence id instead of the default persistence service.
+        #     @param [:left, :midpoint, :right, :trapezoidal] riemann_type An optional approximation type for Riemann
+        #       sum. If nil, :left is used.
+        #
         #   @return [DecimalType, QuantityType, nil] The average value between `start` and `finish`,
         #     or nil if no states could be found.
+        #
         #   @since openHAB 5.0 riemann_type parameter added
 
         # @!method delta_since(timestamp, service = nil)
@@ -158,11 +168,18 @@ module OpenHAB
         #     or nil if no future states could be found.
         #   @since openHAB 4.2
 
-        # @!method delta_between(start, finish, service = nil)
+        # @!method delta_between
         #   Returns the difference 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.
+        #
+        #   @overload delta_between(start, finish, service = nil)
+        #     @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.
+        #
+        #   @overload delta_between(range, service = nil)
+        #     @param [Range<#to_zoned_date_time>] range The time range 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 states could be found.
 
@@ -187,13 +204,19 @@ module OpenHAB
         #   @since openHAB 4.2
         #   @since openHAB 5.0 riemann_type parameter added
 
-        # @!method deviation_between(start, finish, service = nil, riemann_type: nil)
+        # @!method deviation_between
         #   Returns the standard deviation 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.
-        #   @param [:left, :midpoint, :right, :trapezoidal] riemann_type An optional approximation type for Riemann sum.
-        #     If nil, :left is used.
+        #
+        #   @overload deviation_between(start, finish, service = nil)
+        #     @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.
+        #     @param [:left, :midpoint, :right, :trapezoidal] riemann_type An optional approximation type for Riemann
+        #       sum. If nil, :left is used.
+        #   @overload deviation_between(range, service = nil)
+        #     @param [Range<#to_zoned_date_time>] range The time range 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 states could be found.
         #   @since openHAB 5.0 riemann_type parameter added
@@ -214,11 +237,17 @@ module OpenHAB
         #     or nil if no future states could be found.
         #   @since openHAB 4.3
 
-        # @!method median_between(start, finish, service = nil)
+        # @!method median_between
         #   Returns the median 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.
+        #
+        #   @overload median_between(start, finish, service = nil)
+        #     @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.
+        #   @overload median_between(range, service = nil)
+        #     @param [Range<#to_zoned_date_time>] range The time range to search
+        #     @param [Symbol, String] service An optional persistence id instead of the default persistence service.
+        #
         #   @return [DecimalType, QuantityType, nil] The median between `start` and `finish`,
         #     or nil if no states could be found.
         #   @since openHAB 4.3
@@ -238,11 +267,17 @@ module OpenHAB
         #     or nil if no future states could be found.
         #   @since openHAB 4.2
 
-        # @!method sum_between(start, finish, service = nil)
+        # @!method sum_between
         #   Returns the sum 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.
+        #
+        #   @overload sum_between(start, finish, service = nil)
+        #     @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.
+        #   @overload sum_between(range, service = nil)
+        #     @param [Range<#to_zoned_date_time>] range The time range 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 states could be found.
 
@@ -267,13 +302,21 @@ module OpenHAB
         #   @since openHAB 4.2
         #   @since openHAB 5.0 riemann_type parameter added
 
-        # @!method variance_between(start, finish, service = nil, riemann_type: nil)
+        # @!method variance_between
         #   Returns the variance 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.
-        #   @param [:left, :midpoint, :right, :trapezoidal] riemann_type An optional approximation type for Riemann sum.
-        #     If nil, :left is used.
+        #
+        #   @overload variance_between(start, finish, service = nil, reimann_type: nil)
+        #     @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.
+        #     @param [:left, :midpoint, :right, :trapezoidal] riemann_type An optional approximation type for Riemann
+        #       sum. If nil, :left is used.
+        #   @overload variance_between(range, service = nil, reimann_type: nil)
+        #     @param [Range<#to_zoned_date_time>] range The time range to search
+        #     @param [Symbol, String] service An optional persistence id instead of the default persistence service.
+        #     @param [:left, :midpoint, :right, :trapezoidal] riemann_type An optional approximation type for Riemann
+        #       sum. If nil, :left is used.
+        #
         #   @return [DecimalType, QuantityType, nil] The variance between `start` and `finish`,
         #     or nil if no states could be found.
         #   @since openHAB 5.0 riemann_type parameter added
@@ -291,11 +334,17 @@ module OpenHAB
         #   @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)
+        # @!method changed_between?
         #   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
-        #   @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.
+        #
+        #   @overload changed_between?(start, finish, service = nil)
+        #     @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.
+        #   @overload changed_between?(range, service = nil)
+        #     @param [Range<#to_zoned_date_time>] range The time range 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 changed between `start` and `finish`, False otherwise.
 
         # @!method evolution_rate(timestamp, service = nil)
@@ -335,11 +384,17 @@ module OpenHAB
         #     or nil if no future states could be found.
         #   @since openHAB 4.2
 
-        # @!method evolution_rate_between(start, finish, service = nil)
+        # @!method evolution_rate_between
         #   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.
+        #
+        #   @overload evolution_rate_between(start, finish, service = nil)
+        #     @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.
+        #   @overload evolution_rate_between(range, service = nil)
+        #     @param [Range<#to_zoned_date_time>] range The time range 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
@@ -375,11 +430,17 @@ module OpenHAB
         #     or nil if no future states could be found.
         #   @since openHAB 4.2
 
-        # @!method maximum_between(start, finish, service = nil)
+        # @!method maximum_between
         #   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.
+        #
+        #   @overload maximum_between(start, finish, service = nil)
+        #     @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.
+        #   @overload maximum_between(range, service = nil)
+        #     @param [Range<#to_zoned_date_time>] range The time range to search
+        #     @param [Symbol, String] service An optional persistence id instead of the default persistence service.
+        #
         #   @return [PersistedState, nil] The maximum value between `start` and `finish`,
         #     or nil if no states could be found.
 
@@ -398,11 +459,17 @@ module OpenHAB
         #     or nil if no future states could be found.
         #   @since openHAB 4.2
 
-        # @!method minimum_between(start, finish, service = nil)
+        # @!method minimum_between
         #   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.
+        #
+        #   @overload minimum_between(start, finish, service = nil)
+        #     @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.
+        #   @overload minimum_between(range, service = nil)
+        #     @param [Range<#to_zoned_date_time>] range The time range to search
+        #     @param [Symbol, String] service An optional persistence id instead of the default persistence service.
+        #
         #   @return [PersistedState, nil] The minimum value between `start` and `finish`,
         #     or nil if no states could be found.
 
@@ -419,11 +486,17 @@ module OpenHAB
         #   @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)
+        # @!method updated_between?
         #   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
-        #   @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.
+        #
+        #   @overload updated_between?(start, finish, service = nil)
+        #     @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.
+        #   @overload updated_between?(range, service = nil)
+        #     @param [Range<#to_zoned_date_time>] range The time range 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 was updated between `start` and `finish`, False otherwise.
 
         # @!method count_since(timestamp, service = nil)
@@ -439,11 +512,17 @@ module OpenHAB
         #   @return [Integer] The number of values persisted for this item.
         #   @since openHAB 4.2
 
-        # @!method count_between(start, finish, service = nil)
+        # @!method count_between
         #   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.
+        #
+        #   @overload count_between(start, finish, service = nil)
+        #     @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.
+        #   @overload count_between(range, service = nil)
+        #     @param [Range<#to_zoned_date_time>] range The time range 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 count_state_changes_since(timestamp, service = nil)
@@ -459,11 +538,17 @@ module OpenHAB
         #   @return [Integer] The number of values persisted for this item.
         #   @since openHAB 4.2
 
-        # @!method count_state_changes_between(start, finish, service = nil)
+        # @!method count_state_changes_between
         #   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.
+        #
+        #   @overload count_state_changes_between(start, finish, service = nil)
+        #     @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.
+        #   @overload count_state_changes_between(range, service = nil)
+        #     @param [Range<#to_zoned_date_time>] range The time range 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)
@@ -480,11 +565,17 @@ module OpenHAB
         #   @return [Array<PersistedState>] An array of {PersistedState} persisted for this item.
         #   @since openHAB 4.2
 
-        # @!method all_states_between(start, finish, service = nil)
+        # @!method all_states_between
         #   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.
+        #
+        #   @overload all_states_between(start, finish, service = nil)
+        #     @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.
+        #   @overload all_states_between(range, service = nil)
+        #     @param [Range<#to_zoned_date_time>] range The time range 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.0
 
@@ -508,13 +599,21 @@ module OpenHAB
         #     or nil if no previous states could be found.
         #   @since openHAB 5.0
 
-        # @!method riemann_sum_between(start, finish, service = nil, riemann_type: nil)
+        # @!method riemann_sum_between
         #   Returns the Riemann sum of 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.
-        #   @param [:left, :midpoint, :right, :trapezoidal] riemann_type An optional approximation type for Riemann sum.
-        #     If nil, :left is used.
+        #
+        #   @overload riemann_sum_between(start, finish, service = nil, riemann_type: nil)
+        #     @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.
+        #     @param [:left, :midpoint, :right, :trapezoidal] riemann_type An optional approximation type for Riemann
+        #       sum. If nil, :left is used.
+        #   @overload riemann_sum_between(range, service = nil, riemann_type: nil)
+        #     @param [Range<#to_zoned_date_time>] range The time range to search
+        #     @param [Symbol, String] service An optional persistence id instead of the default persistence service.
+        #     @param [:left, :midpoint, :right, :trapezoidal] riemann_type An optional approximation type for Riemann
+        #       sum. If nil, :left is used.
+        #
         #   @return [DecimalType, QuantityType, nil] The riemann sum between `start` and `finish`,
         #     or nil if no previous states could be found.
         #   @since openHAB 5.0
@@ -533,11 +632,17 @@ module OpenHAB
         #   @return [void]
         #   @since openHAB 4.2
 
-        # @!method remove_all_states_between(start, finish, service = nil)
+        # @!method remove_all_states_between
         #   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.
+        #
+        #   @overload remove_all_states_between(start, finish, service = nil)
+        #     @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.
+        #   @overload remove_all_states_between(range, service = nil)
+        #     @param [Range<#to_zoned_date_time>] range The time range to remove
+        #     @param [Symbol, String] service An optional persistence id instead of the default persistence service.
+        #
         #   @return [void]
         #   @since openHAB 4.2
 
@@ -756,17 +861,23 @@ module OpenHAB
 
             method = "#{method}_between"
             class_eval <<~RUBY, __FILE__, __LINE__ + 1
-              def #{method}#{suffix}(start, finish, service = nil#{riemann_param}) # def changed_between?(start, finish, service = nil, riemann_type: nil)
-                service ||= persistence_service                                    #   service ||= persistence_service
-                result = Actions::PersistenceExtensions.#{method}(                 #   result = Actions::PersistenceExtensions.average_between(
-                  self,                                                            #     self,
-                  start.to_zoned_date_time,                                        #     start.to_zoned_date_time,
-                  finish.to_zoned_date_time,                                       #     finish.to_zoned_date_time,
-                  #{riemann_arg}                                                   #     to_riemann_type(riemann_type),
-                  service&.to_s                                                    #     service&.to_s
-                )                                                                  #   )
-                wrap_result(result, quantify: #{quantify})                         #   wrap_result(result, quantify: false)
-              end                                                                  # end
+              def #{method}#{suffix}(start, finish = nil, service = nil#{riemann_param})             # def changed_between?(start, finish, service = nil, riemann_type: nil)
+                if start.is_a?(Range)                                                                #   if start.is_a?(Range)
+                  raise ArgumentError, "wrong number of arguments (given 3, expected 2)" if service  #     raise ArgumentError, "wrong number of arguments (given 3, expected 2)" if service
+                  service = finish                                                                   #     service = finish
+                  finish = start.end                                                                 #     finish = start.end
+                  start = start.begin                                                                #     start = start.begin
+                end                                                                                  #   end
+                service ||= persistence_service                                                      #   service ||= persistence_service
+                result = Actions::PersistenceExtensions.#{method}(                                   #   result = Actions::PersistenceExtensions.average_between(
+                  self,                                                                              #     self,
+                  start.to_zoned_date_time,                                                          #     start.to_zoned_date_time,
+                  finish.to_zoned_date_time,                                                         #     finish.to_zoned_date_time,
+                  #{riemann_arg}                                                                     #     to_riemann_type(riemann_type),
+                  service&.to_s                                                                      #     service&.to_s
+                )                                                                                    #   )
+                wrap_result(result, quantify: #{quantify})                                           #   wrap_result(result, quantify: false)
+              end                                                                                    # end
             RUBY
           end
         end

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

@@ -571,9 +571,9 @@ module Enumerable
   # Returns a new array of items that are a semantics Location (optionally of one of the given types)
   #
   # @param [SemanticTag] types
-  #   Pass 1 or more classes that are sub-classes of {Semantics::Location Semantics::Location}.
+  #   Pass 1 or more tags that are sub-tags of {Semantics::Location Semantics::Location}.
   #   Note that when comparing against semantic tags, it does a sub-class check by default.
-  #   So if you search for [Room], you'll get items tagged with [LivingRoom], [Kitchen], etc.
+  #   So if you search for `Room`, you'll get items tagged with `LivingRoom`, `Kitchen`, etc.
   # @param [true, false] subclasses
   #   If true, match all subclasses of the given types.
   #   If false, only match the exact type.
@@ -614,9 +614,9 @@ module Enumerable
   #   before calling {#points}. See the example with {#points}.
   #
   # @param [SemanticTag] types
-  #   Pass 1 or more classes that are sub-classes of {Semantics::Equipment Semantics::Equipment}.
-  #   Note that when comparing against semantic tags, it does a sub-class check by default.
-  #   So if you search for [Fan], you'll get items tagged with [CeilingFan], [KitchenHood], etc.
+  #   Pass 1 or more tags that are sub-classes of {Semantics::Equipment Semantics::Equipment}.
+  #   Note that when comparing against semantic tags, it does a sub-class check by default,
+  #   so if you search for `Fan`, you'll get items tagged with `CeilingFan`, `KitchenHood`, etc.
   # @param [true, false] subclasses
   #   If true, match all subclasses of the given types.
   #   If false, only match the exact type.
@@ -649,11 +649,15 @@ module Enumerable
 
   # Returns a new array of items that are semantics points (optionally of a given type)
   #
-  # @param [SemanticTag] point_or_property_types
-  #   Pass 1 or 2 classes that are sub-classes of {Semantics::Point Semantics::Point} or
-  #   {Semantics::Property Semantics::Property}.
-  #   Note that when comparing against semantic tags, it does a sub-class check by default.
-  #   So if you search for [Control], you'll get items tagged with [Switch].
+  # @param [SemanticTag, Array<SemanticTag>] point_or_property_types
+  #   Pass 1 or more tags that are sub-tags of {Semantics::Point Semantics::Point} or
+  #   {Semantics::Property Semantics::Property}. If multiple point _or_ property
+  #   tags are given, the point only has to match one of them. But if point _and_
+  #   property tag(s) are given, the point must match both a point and property tag.
+  #   You may also pass an array of tags, to match multiple combination of tags at once.
+  #   See the air temperature/speed control example below.
+  #   Note that when comparing against semantic tags, it does a sub-class check by default,
+  #   so if you search for `Control`, you'll get items tagged with `Switch`.
   # @param [true, false] subclasses
   #   If true, match all subclasses of the given types.
   #   If false, only match the exact type.
@@ -662,35 +666,58 @@ module Enumerable
   # @example Get all the power switch items for every equipment in a room
   #   lGreatRoom.equipments.members.points(Semantics::Switch)
   #
+  # @example Get (all) the temperature setpoints for a thermostat
+  #   eMainFloorThermostat.points(Semantics::Setpoint, Semantics::Temperature)
+  #
+  # @example Get all the brightness and color (light) points in a room
+  #   lKitchen.equipments.members.points(Semantics::Brightness, Semantics::Color)
+  #
+  # @example Get all the brightness and color (light) control points in a room
+  #   lKitchen.equipments.members.points(Semantics::Control, Semantics::Brightness, Semantics::Color)
+  #
+  # @example Get the air temperature and speed control points in a room
+  #   lGreatRoom.equipments.members.points([Semantics::Measurement, Semantics::Temperature],
+  #                                        [Semantics::Control, Semantics::Speed])
+  #   # => [GreatRoom_AirTemp, GreatRoom_FanSpeed]
+  #
   # @see #members
   #
   def points(*point_or_property_types, subclasses: true)
-    unless (0..2).cover?(point_or_property_types.length)
-      raise ArgumentError, "wrong number of arguments (given #{point_or_property_types.length}, expected 0..2)"
-    end
+    return select(&:point?) if point_or_property_types.empty?
 
     begin
-      raise ArgumentError unless point_or_property_types.all? do |tag|
-                                   tag < Semantics::Point ||
-                                   tag < Semantics::Property
-                                 end
+      arrays, non_arrays = point_or_property_types.partition { |tag| tag.is_a?(Array) }
+      arrays << non_arrays unless non_arrays.empty?
+
+      arrays.map! do |array|
+        points = array.select { |tag| tag < Semantics::Point }
+        properties = array.select { |tag| tag < Semantics::Property }
+        raise ArgumentError unless points.length + properties.length == array.length
+
+        [points, properties]
+      end
     rescue ArgumentError, TypeError
-      raise ArgumentError, "point_or_property_types must all be a subclass of Point or Property"
-    end
-    if point_or_property_types.count { |tag| tag < Semantics::Point } > 1 ||
-       point_or_property_types.count { |tag| tag < Semantics::Property } > 1
-      raise ArgumentError, "point_or_property_types cannot both be a subclass of Point or Property"
+      raise ArgumentError, "point_or_property_types must all be arrays, or a subclass of Point or Property"
     end
 
     select do |point|
-      point.point? && point_or_property_types.all? do |tag|
+      point.point? && arrays.any? do |(points, properties)|
         if subclasses
-          (tag < Semantics::Point && point.point_type&.<=(tag)) ||
-            (tag < Semantics::Property && point.property_type&.<=(tag))
+          next false if !points.empty? &&
+                        ((point_type = point.point_type).nil? ||
+                         points.none? { |tag| point_type <= tag })
+          next false if !properties.empty? &&
+                        ((property_type = point.property_type).nil? ||
+                         properties.none? { |tag| property_type <= tag })
         else
-          (tag < Semantics::Point && point.point_type == tag) ||
-            (tag < Semantics::Property && point.property_type == tag)
+          next false if !points.empty? &&
+                        ((point_type = point.point_type).nil? ||
+                         points.none?(point_type))
+          next false if !properties.empty? &&
+                        ((property_type = point.property_type).nil? ||
+                         properties.none?(property_type))
         end
+        true
       end
     end
   end

data/lib/openhab/dsl/version.rb

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

data/lib/openhab/rspec/karaf.rb

@@ -7,6 +7,7 @@ require "time"
 
 require_relative "jruby"
 require_relative "shell"
+require_relative "mocks/synchronous_executor"
 
 module OpenHAB
   module RSpec
@@ -291,7 +292,6 @@ module OpenHAB
             cfg.update(props)
           end
           wait_for_service("org.openhab.core.automation.RuleManager") do |re|
-            require_relative "mocks/synchronous_executor"
             # overwrite thCallbacks to one that will spy to remove threading
             field = re.class.java_class.declared_field :thCallbacks
             field.accessible = true
@@ -430,8 +430,6 @@ module OpenHAB
           end
 
           if bundle_name == "org.openhab.core"
-            require_relative "mocks/synchronous_executor"
-
             org.openhab.core.common.ThreadPoolManager.field_accessor :pools
             org.openhab.core.common.ThreadPoolManager.pools = Mocks::SynchronousExecutorMap.instance
           end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: openhab-scripting
 version: !ruby/object:Gem::Version
-  version: 5.38.5
+  version: 5.39.0
 platform: ruby
 authors:
 - Brian O'Connell