openhab-scripting 5.35.1 → 5.36.0

data/lib/openhab/core/types/hsb_type.rb

@@ -12,10 +12,8 @@ module OpenHAB
       # {HSBType} is a complex type with constituents for hue, saturation and
       #  brightness and can be used for color items.
       class HSBType < PercentType
-        if OpenHAB::Core.version >= OpenHAB::Core::V4_0
-          java_import org.openhab.core.util.ColorUtil
-          private_constant :ColorUtil
-        end
+        java_import org.openhab.core.util.ColorUtil
+        private_constant :ColorUtil
 
         # @!constant BLACK
         #   @return [HSBType]
@@ -99,7 +97,7 @@ module OpenHAB
               end
             end
 
-            super(*args)
+            super
           end
 
           # Create HSBType from a color temperature

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

@@ -31,7 +31,7 @@ module OpenHAB
             end
           end
 
-          super(*args)
+          super
         end
 
         #

data/lib/openhab/core/types/quantity_type.rb

@@ -189,7 +189,7 @@ module OpenHAB
         }.each do |java_op, ruby_op|
           convert = "self.class.new(other, thread_unit)"
 
-          class_eval( # rubocop:disable Style/DocumentDynamicEvalDefinition https://github.com/rubocop/rubocop/issues/10179
+          class_eval( # rubocop:disable Style/DocumentDynamicEvalDefinition -- https://github.com/rubocop/rubocop/issues/10179
             # def +(other)
             #   logger.trace { "#{self} + #{other} (#{other.class})" }
             #   other = other.state if other.is_a?(Core::Items::Persistence::PersistedState)
@@ -209,6 +209,9 @@ module OpenHAB
             #     else
             #       raise TypeError, "#{other.class} can't be coerced into #{self.class}"
             #     end
+            #   elsif !other.is_a?(Numeric) && !other.is_a?(java.lang.Number) &&
+            #     other.respond_to?(:coerce) && (lhs, rhs = other.coerce(self))
+            #     return lhs + rhs
             #   else
             #     raise TypeError,
             #       "#{self.class} can only be added with another #{self.class} outside a unit block"
@@ -234,6 +237,9 @@ module OpenHAB
                   else
                     raise TypeError, "\#{other.class} can't be coerced into \#{self.class}"
                   end
+                elsif !other.is_a?(Numeric) && !other.is_a?(java.lang.Number) &&
+                  other.respond_to?(:coerce) && (lhs, rhs = other.coerce(self))
+                  return lhs #{ruby_op} rhs
                 else
                   raise TypeError,
                     "\#{self.class} can only be #{java_op}ed with another \#{self.class} outside a unit block"
@@ -247,7 +253,7 @@ module OpenHAB
           multiply: :*,
           divide: :/
         }.each do |java_op, ruby_op|
-          class_eval( # rubocop:disable Style/DocumentDynamicEvalDefinition https://github.com/rubocop/rubocop/issues/10179
+          class_eval( # rubocop:disable Style/DocumentDynamicEvalDefinition -- https://github.com/rubocop/rubocop/issues/10179
             # def *(other)
             #   logger.trace { "#{self} * #{other} (#{other.class})" }
             #   other = other.state if other.is_a?(Core::Items::Persistence::PersistedState)
@@ -287,6 +293,20 @@ module OpenHAB
           )
         end
 
+        #
+        # Convert this {QuantityType} into a {Duration} if the unit is time-based.
+        #
+        # @return [Duration] a {Duration} if the unit is time-based
+        # @raise [TypeError] if the unit is not time-based
+        #
+        # @see CoreExt::Java::TemporalAmount#to_temporal_amount
+        #
+        def to_temporal_amount
+          return Duration.of_nanos(to_unit("ns").to_i) if unit.compatible?(Units::SECOND)
+
+          raise TypeError, "#{self} is not a time-based Quantity"
+        end
+
         # if it's a dimensionless quantity, change the unit to match other_unit
         # @!visibility private
         def unitize(other_unit = unit, relative: false)

data/lib/openhab/core/types/raw_type.rb

@@ -10,14 +10,20 @@ module OpenHAB
       #
       # This type can be used for all binary data such as images, documents, sounds etc.
       #
-      class RawType # rubocop:disable Lint/EmptyClass
+      class RawType
         # @!parse include State
 
-        # @!method mime_type
+        # @attribute [r] mime_type
         #   @return [String]
 
-        # @!method bytes
-        #   @return [String]
+        # @attribute[r] bytes
+        #   @return [byte[]]
+
+        # @attribute [r] bytesize
+        # @return [Integer]
+        def bytesize
+          bytes.size
+        end
       end
     end
   end

data/lib/openhab/core/types/state_description.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module OpenHAB
+  module Core
+    module Types
+      StateDescription = org.openhab.core.types.StateDescription
+
+      # Describes restrictions of an item state and gives information how to interpret it
+      class StateDescription
+        # @!attribute [r] step
+        #   @return [BigDecimal, nil]
+
+        # @!attribute [r] pattern
+        #   @return [String, nil]
+
+        # @!attribute [r] read_only?
+        #   @return [true, false]
+
+        # @!attribute [r] options
+        #   @return [Array<org.openhab.core.types.StateOption>]
+
+        # @!attribute [r] range
+        # @return [Range, nil]
+        def range
+          return nil unless minimum || maximum
+
+          minimum..maximum
+        end
+
+        # @return [String]
+        def inspect
+          s = "#<OpenHAB::Core::Types::StateDescription"
+          r = range
+          s += " read_only" if read_only?
+          s += " range=#{r}" if r
+          s += " step=#{step}" if step
+          s += " pattern=#{pattern.inspect}" if pattern && !pattern.empty?
+          unless options.empty?
+            s += " options=["
+            options.each_with_index do |o, i|
+              s += ", " if i != 0
+
+              s += o.value.inspect
+
+              s += " (#{o.label.inspect})" if o.value != o.label && !o.label.nil?
+            end
+            s += "]"
+          end
+          "#{s}>"
+        end
+      end
+    end
+  end
+end

data/lib/openhab/core/types/time_series.rb

@@ -1,8 +1,5 @@
 # frozen_string_literal: true
 
-# @deprecated OH4.0 this guard is not needed on OH4.1
-return unless OpenHAB::Core.version >= OpenHAB::Core::V4_1
-
 require "forwardable"
 require "openhab/core/lazy_array"
 

data/lib/openhab/core/types.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-Dir[File.expand_path("types/*.rb", __dir__)].sort.each do |f|
+Dir[File.expand_path("types/*.rb", __dir__)].each do |f|
   require f
 end
 
@@ -47,7 +47,7 @@ module OpenHAB
         klass.remove_method(:==)
 
         # dynamically define predicate methods
-        klass.values.each do |value| # rubocop:disable Style/HashEachMethods this isn't a Ruby hash
+        klass.values.each do |value| # rubocop:disable Style/HashEachMethods -- this isn't a Ruby hash
           # include all the aliases that we define for items both command and
           # state aliases (since types can be interrogated as an incoming
           # command, or as the state of an item)

data/lib/openhab/core/value_cache.rb

@@ -57,8 +57,8 @@ module OpenHAB
       # @yieldreturn [Object] new value
       # @return [Object] new value or current value
       #
-      def compute_if_absent(key, &block)
-        get(key.to_s, &block)
+      def compute_if_absent(key, &)
+        get(key.to_s, &)
       end
 
       # @see https://docs.ruby-lang.org/en/master/Hash.html#method-i-5B-5D-3D Hash#[]=
@@ -97,7 +97,7 @@ module OpenHAB
             end
           else
             get(key) do
-              raise KeyError.new("key not found: #{key.inspect}", key: key)
+              raise KeyError.new("key not found: #{key.inspect}", key:)
             end
           end
         else

data/lib/openhab/core.rb

@@ -3,12 +3,10 @@
 module OpenHAB
   # Contains classes and modules that wrap actual openHAB objects
   module Core
-    # The openHAB Version. >= 3.4.0 is required.
+    # The openHAB Version. >= 4.1 is required.
     # @return [String]
     VERSION = org.openhab.core.OpenHAB.version.freeze
 
-    # @!visibility private
-    V4_0 = Gem::Version.new("4.0.0").freeze
     # @!visibility private
     V4_1 = Gem::Version.new("4.1.0").freeze
     # @!visibility private
@@ -23,7 +21,7 @@ module OpenHAB
       @version ||= Gem::Version.new(VERSION).release.freeze
     end
 
-    raise "`openhab-scripting` requires openHAB >= 3.4.0" unless version >= Gem::Version.new("3.4.0")
+    raise "`openhab-scripting` requires openHAB >= 4.1.0" unless version >= V4_1
 
     # @return [Integer] Number of seconds to wait between checks for automation manager
     CHECK_DELAY = 10
@@ -133,6 +131,6 @@ end
 # several classes rely on this, so force it to load earlier
 require_relative "core/provider"
 
-Dir[File.expand_path("core/**/*.rb", __dir__)].sort.each do |f|
+Dir[File.expand_path("core/**/*.rb", __dir__)].each do |f|
   require f
 end

data/lib/openhab/core_ext/java/duration.rb

@@ -55,11 +55,24 @@ module OpenHAB
 
         remove_method :==
 
-        # @return [Integer, nil]
+        #
+        # Comparisons against other types may be done if supported by that type's coercion.
+        #
+        # @return [Numeric, QuantityType, nil]
+        #
         def <=>(other)
-          return to_f <=> other if other.is_a?(Numeric)
-
-          super
+          logger.trace { "(#{self.class}) #{self} <=> #{other} (#{other.class})" }
+          case other
+          when Duration then super
+          when Numeric then to_f <=> other
+          when QuantityType then self <=> other.to_temporal_amount
+          else
+            if other.respond_to?(:coerce) && (lhs, rhs = other.coerce(self))
+              lhs <=> rhs
+            else
+              super
+            end
+          end
         rescue TypeError
           nil
         end
@@ -72,6 +85,8 @@ module OpenHAB
         #
         def coerce(other)
           return [other.seconds, self] if other.is_a?(Numeric)
+          # We want to return the same type as other, e.g. QuantityType + Duration = QuantityType
+          return [other, to_nanos | "ns"] if other.is_a?(QuantityType) && other.unit.compatible?(Units::SECOND)
 
           [other.to_i.seconds, self] if other.is_a?(Period)
         end
@@ -87,7 +102,9 @@ module OpenHAB
           #     plus_seconds(other)
           #   elsif other.is_a?(Numeric)
           #     plus(other.seconds)
-          #   elsif other.respond_to?(:coerce) && (rhs, lhs = other.coerce(self))
+          #   elsif other.is_a?(QuantityType)
+          #     plus(other.to_temporal_amount)
+          #   elsif other.respond_to?(:coerce) && (lhs, rhs = other.coerce(self))
           #     lhs + rhs
           #   else
           #     raise TypeError, "#{other.class} can't be coerced into Duration"
@@ -101,7 +118,9 @@ module OpenHAB
                 #{java_op}_seconds(other)
               elsif other.is_a?(Numeric)
                 #{java_op}(other.seconds)
-              elsif other.respond_to?(:coerce) && (rhs, lhs = other.coerce(self))
+              elsif other.is_a?(QuantityType)
+                #{java_op}(other.to_temporal_amount)
+              elsif other.respond_to?(:coerce) && (lhs, rhs = other.coerce(self))
                 lhs #{ruby_op} rhs
               else
                 raise TypeError, "\#{other.class} can't be coerced into Duration"
@@ -121,7 +140,7 @@ module OpenHAB
           #     Duration.of_seconds(to_f * other)
           #   elsif other.is_a?(Duration)
           #     Duration.of_seconds(to_f * other.to_f)
-          #   elsif other.respond_to?(:coerce) && (rhs, lhs = other.coerce(self))
+          #   elsif other.respond_to?(:coerce) && (lhs, rhs = other.coerce(self))
           #     lhs * rhs
           #   else
           #     raise TypeError, "#{other.class} can't be coerced into Duration"
@@ -135,7 +154,7 @@ module OpenHAB
                 Duration.of_seconds(to_f #{ruby_op} other)
               elsif other.is_a?(Duration)
                 Duration.of_seconds(to_f #{ruby_op} other.to_f)
-              elsif other.respond_to?(:coerce) && (rhs, lhs = other.coerce(self))
+              elsif other.respond_to?(:coerce) && (lhs, rhs = other.coerce(self))
                 lhs #{ruby_op} rhs
               else
                 raise TypeError, "\#{other.class} can't be coerced into Duration"

data/lib/openhab/core_ext/java/list.rb

@@ -217,7 +217,7 @@ module Java::JavaUtil::List # rubocop:disable Style/ClassAndModuleChildren
   end
 
   def intersect?(other_ary)
-    !(self & other_ary).empty?
+    !(self & other_ary).empty? # rubocop:disable Style/ArrayIntersect
   end
 
   def keep_if?

data/lib/openhab/core_ext/java/local_date.rb

@@ -26,7 +26,7 @@ module OpenHAB
 
         # @!scope instance
 
-        # @param [TemporalAmount, LocalDate, Numeric] other
+        # @param [TemporalAmount, LocalDate, Numeric, QuantityType] other
         #   If other is a Numeric, it's interpreted as days.
         # @return [LocalDate] If other is a TemporalAmount or Numeric
         # @return [Period] If other is a LocalDate
@@ -42,12 +42,14 @@ module OpenHAB
             minus_days(other.to_days)
           when Numeric
             minus_days(other.ceil)
+          when QuantityType
+            minus_days(other.to_temporal_amount.to_days)
           else
             minus(other)
           end
         end
 
-        # @param [TemporalAmount, Numeric] other
+        # @param [TemporalAmount, Numeric, QuantityType] other
         #   If other is a Numeric, it's interpreted as days.
         # @return [LocalDate]
         def +(other)
@@ -56,6 +58,8 @@ module OpenHAB
             plus_days(other.to_days)
           when Numeric
             plus_days(other.to_i)
+          when QuantityType
+            plus_days(other.to_temporal_amount.to_days)
           else
             plus(other)
           end

data/lib/openhab/core_ext/java/local_time.rb

@@ -67,23 +67,25 @@ module OpenHAB
           end
         end
 
-        # @param [TemporalAmount, Numeric] other
+        # @param [TemporalAmount, Numeric, QuantityType] other
         #   If other is a Numeric, it's interpreted as seconds.
         # @return [LocalTime]
         def -(other)
           return minus(other.seconds) if other.is_a?(Numeric)
           return self if other.is_a?(Period)
 
+          other = other.to_temporal_amount if other.is_a?(QuantityType)
           minus(other)
         end
 
-        # @param [TemporalAmount, Numeric] other
+        # @param [TemporalAmount, Numeric, QuantityType] other
         #   If other is a Numeric, it's interpreted as seconds.
         # @return [LocalTime]
         def +(other)
           return plus(other.seconds) if other.is_a?(Numeric)
           return self if other.is_a?(Period)
 
+          other = other.to_temporal_amount if other.is_a?(QuantityType)
           plus(other)
         end
 

data/lib/openhab/core_ext/java/map.rb

@@ -16,11 +16,11 @@ module Java::JavaUtil::Map # rubocop:disable Style/ClassAndModuleChildren
   end
 
   def except(*keys)
-    reject { |k, _v| keys.include?(k) }
+    reject { |k, _v| keys.include?(k) } # rubocop:disable Style/HashExcept
   end
 
   def slice(*keys)
-    select { |k, _v| keys.include?(k) }
+    select { |k, _v| keys.include?(k) } # rubocop:disable Style/HashSlice
   end
 
   def transform_keys(hash2 = nil)

data/lib/openhab/core_ext/java/period.rb

@@ -36,6 +36,7 @@ module OpenHAB
         # @return [Integer, nil]
         def <=>(other)
           return to_i <=> other if other.is_a?(Numeric)
+          return to_i <=> other.to_i if other.is_a?(Duration)
 
           super
         end
@@ -43,11 +44,13 @@ module OpenHAB
         #
         # Convert `self` and `other` to {Duration}, if `other` is a Numeric
         #
-        # @param [Numeric] other
+        # @param [Numeric, Duration] other
         # @return [Array, nil]
         #
         def coerce(other)
-          [other.seconds, to_i.seconds] if other.is_a?(Numeric)
+          return [other.seconds, to_i.seconds] if other.is_a?(Numeric)
+
+          [other, to_i.seconds] if other.is_a?(Duration)
         end
 
         {
@@ -55,11 +58,11 @@ module OpenHAB
           minus: :-
         }.each do |java_op, ruby_op|
           # def +(other)
-          #   if other.is_a?(Period)
+          #   if other.is_a?(Period) || other.is_a?(Duration)
           #     plus(other)
           #   elsif other.is_a?(Numeric)
           #     self + other.seconds
-          #   elsif other.respond_to?(:coerce) && (rhs, lhs = other.coerce(self))
+          #   elsif other.respond_to?(:coerce) && (lhs, rhs = other.coerce(self))
           #     lhs + rhs
           #   else
           #     raise TypeError, "#{other.class} can't be coerced into Period"
@@ -71,7 +74,7 @@ module OpenHAB
                 #{java_op}(other)
               elsif other.is_a?(Numeric)
                 self #{ruby_op} other.seconds
-              elsif other.respond_to?(:coerce) && (rhs, lhs = other.coerce(self))
+              elsif other.respond_to?(:coerce) && (lhs, rhs = other.coerce(self))
                 lhs #{ruby_op} rhs
               else
                 raise TypeError, "\#{other.class} can't be coerced into Period"
@@ -84,7 +87,7 @@ module OpenHAB
         def *(other)
           if other.is_a?(Integer)
             multipliedBy(other)
-          elsif other.respond_to?(:coerce) && (rhs, lhs = other.coerce(self))
+          elsif other.respond_to?(:coerce) && (lhs, rhs = other.coerce(self))
             lhs * rhs
           else
             raise TypeError, "#{other.class} can't be coerced into Period"

data/lib/openhab/core_ext/java/temporal_amount.rb

@@ -28,6 +28,11 @@ module OpenHAB
         def inspect
           to_s
         end
+
+        # @return [self]
+        def to_temporal_amount
+          self
+        end
       end
     end
   end

data/lib/openhab/core_ext/java/zoned_date_time.rb

@@ -39,27 +39,33 @@ module OpenHAB
         # @return [Month]
         alias_method :to_month, :month
 
-        # @param [TemporalAmount, #to_zoned_date_time, Numeric] other
+        # @param [TemporalAmount, #to_zoned_date_time, Numeric, QuantityType] other
         #   If other is a Numeric, it's interpreted as seconds.
         # @return [Duration] If other responds to #to_zoned_date_time
-        # @return [ZonedDateTime] If other is a TemporalAmount
+        # @return [ZonedDateTime] If other is a TemporalAmount or a Time QuantityType
         def -(other)
           if other.respond_to?(:to_zoned_date_time)
             java.time.Duration.between(other.to_zoned_date_time, self)
           elsif other.is_a?(Numeric)
             minus(other.seconds)
+          elsif other.is_a?(QuantityType)
+            minus(other.to_temporal_amount)
           else
             minus(other)
           end
         end
 
-        # @param [TemporalAmount, Numeric] other
+        # @param [TemporalAmount, Numeric, QuantityType] other
         #   If other is a Numeric, it's interpreted as seconds.
         # @return [ZonedDateTime]
         def +(other)
-          return plus(other.seconds) if other.is_a?(Numeric)
-
-          plus(other)
+          if other.is_a?(Numeric)
+            plus(other.seconds)
+          elsif other.is_a?(QuantityType)
+            plus(other.to_temporal_amount)
+          else
+            plus(other)
+          end
         end
 
         #

data/lib/openhab/core_ext/ruby/date.rb

@@ -12,11 +12,11 @@ class Date
   #
   # Extends {#+} to allow adding a {java.time.temporal.TemporalAmount TemporalAmount}
   #
-  # @param [java.time.temporal.TemporalAmount] other
-  # @return [LocalDate] If other is a {java.time.temporal.TemporalAmount TemporalAmount}
+  # @param [java.time.temporal.TemporalAmount, QuantityType] other
+  # @return [LocalDate] If other is a {java.time.temporal.TemporalAmount TemporalAmount} or a Time {QuantityType}
   #
   def plus_with_temporal(other)
-    return to_local_date + other if other.is_a?(java.time.temporal.TemporalAmount)
+    return to_local_date + other.to_temporal_amount if other.respond_to?(:to_temporal_amount)
 
     plus_without_temporal(other)
   end
@@ -26,13 +26,14 @@ class Date
   #
   # Extends {#-} to allow subtracting a {java.time.temporal.TemporalAmount TemporalAmount}
   #
-  # @param [java.time.temporal.TemporalAmount] other
-  # @return [LocalDate] If other is a {java.time.temporal.TemporalAmount TemporalAmount}
+  # @param [java.time.temporal.TemporalAmount, QuantityType] other
+  # @return [LocalDate] If other is a {java.time.temporal.TemporalAmount TemporalAmount} or a Time {QuantityType}
   #
   def minus_with_temporal(other)
-    case other
-    when java.time.temporal.TemporalAmount, java.time.LocalDate
+    if other.instance_of?(java.time.LocalDate)
       to_local_date - other
+    elsif other.respond_to?(:to_temporal_amount)
+      to_local_date - other.to_temporal_amount
     else
       minus_without_temporal(other)
     end

data/lib/openhab/core_ext/ruby/date_time.rb

@@ -15,7 +15,7 @@ class DateTime < Date
 
   # (see Time#plus_with_temporal)
   def plus_with_temporal(other)
-    return to_zoned_date_time + other if other.is_a?(java.time.temporal.TemporalAmount)
+    return to_zoned_date_time + other.to_temporal_amount if other.respond_to?(:to_temporal_amount)
 
     plus_without_temporal(other)
   end
@@ -24,7 +24,7 @@ class DateTime < Date
 
   # (see Time#minus_with_temporal)
   def minus_with_temporal(other)
-    return to_zoned_date_time - other if other.is_a?(java.time.temporal.TemporalAmount)
+    return to_zoned_date_time - other.to_temporal_amount if other.respond_to?(:to_temporal_amount)
 
     # Exclude subtracting against the same class
     if other.respond_to?(:to_zoned_date_time) && !other.is_a?(self.class)

data/lib/openhab/core_ext/ruby/time.rb

@@ -18,7 +18,7 @@ class Time
   # @return [Time] If other is a Numeric
   #
   def plus_with_temporal(other)
-    return to_zoned_date_time + other if other.is_a?(java.time.temporal.TemporalAmount)
+    return to_zoned_date_time + other.to_temporal_amount if other.respond_to?(:to_temporal_amount)
 
     plus_without_temporal(other)
   end
@@ -53,7 +53,7 @@ class Time
   # @return [Float] If other is a Time
   #
   def minus_with_temporal(other)
-    return to_zoned_date_time - other if other.is_a?(java.time.temporal.TemporalAmount)
+    return to_zoned_date_time - other.to_temporal_amount if other.respond_to?(:to_temporal_amount)
 
     # Exclude subtracting against the same class
     if other.respond_to?(:to_zoned_date_time) && !other.is_a?(self.class)

data/lib/openhab/core_ext.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-Dir[File.expand_path("core_ext/**/*.rb", __dir__)].sort.each do |f|
+Dir[File.expand_path("core_ext/**/*.rb", __dir__)].each do |f|
   require f
 end
 

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

@@ -107,7 +107,7 @@ module OpenHAB
                       verify: false)
           # Extract the named arguments into a hash
           @parameters << method(__method__).parameters
-                                           .select { |param_type, _| param_type == :key }
+                                           .select { |param_type, _| param_type == :key } # rubocop:disable Style/HashSlice
                                            .to_h { |_, key| [key, binding.local_variable_get(key)] }
                                            .then do |p|
             p[:options] = p[:options].map do |opt_value, opt_label|