openhab-scripting 4.8.5 → 4.10.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 19b14c62e681500abaa99858522f7592e0a4d93f6966a5cf8e99157b0944cbe6
-  data.tar.gz: 071556f83604d539af3620a0796eef993edfc0bb224ad3dd08cf7d5a71e9d593
+  metadata.gz: 2363b08b3ff2cf49420f2083bad82d1c20fcc927104641bbcc824495bd0ba520
+  data.tar.gz: a589c5a4e5a92a8c4899784a70a1a2bd5c352ae46d0ccd446516369fb1ce39ad
 SHA512:
-  metadata.gz: '01429a840f1af1e81886988f00ad628fa01dd7a7423ef2e20c59eb1d40822b573115d12a0c8c6fc093012ad29a70666bf280de52a789a8dc8cf6b0c7d2eb1867'
-  data.tar.gz: 28aab00e8742851f08fee9535b39c913f78f4c7200f2bdbd8788e4d6c8ac8ae6f202a7f3e4675e0e02af2bbc953b6a10114b93987eff5c6ec37e1d6ad0f8ddeb
+  metadata.gz: dfe40bd0793be059b2196d18ea6e68fba9415b92326cb9e55b6a1bcbf68bc778ed96cb5f1a97ce2f6a61f6164452dea25e0c6f905bdd88c206cafc19194e850e
+  data.tar.gz: cdb36b59bd35ab74fa08cbfa1e011c73c3111f04702451e16698c8f701fadedfb6f68af514149dc6bac6a9808ad206ea5eba738a1cd78f5e2efee2b6fb52cd16

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

@@ -39,8 +39,6 @@ module OpenHAB
           logger.trace("Coercing #{self} as a request from #{other.class}")
           return [other, nil] unless state?
           return [other, state] if other.is_a?(Types::HSBType) || other.respond_to?(:to_str)
-
-          raise TypeError, "can't convert #{other.class} into #{self.class}"
         end
 
         # any method that exists on {Types::HSBType} gets forwarded to +state+

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

@@ -40,8 +40,6 @@ module OpenHAB
           logger.trace("Coercing #{self} as a request from #{other.class}")
           return [other, nil] unless state?
           return [other, state] if other.is_a?(Types::DateTimeType) || other.respond_to?(:to_time)
-
-          raise TypeError, "can't convert #{other.class} into #{self.class}"
         end
 
         # any method that exists on DateTimeType, Java's ZonedDateTime, or

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

@@ -39,8 +39,6 @@ module OpenHAB
           logger.trace("Coercing #{self} as a request from #{other.class}")
           return [other, nil] unless state?
           return [other, state] if other.is_a?(Types::PointType) || other.respond_to?(:to_str)
-
-          raise TypeError, "can't convert #{other.class} into #{self.class}"
         end
 
         # OpenHAB has this method, but it _only_ accepts PointType, so remove it and delegate

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

@@ -47,8 +47,6 @@ module OpenHAB
           logger.trace("Coercing #{self} as a request from #{other.class}")
           return [other, nil] unless state?
           return [other, state] if other.is_a?(Types::NumericType) || other.respond_to?(:to_d)
-
-          raise TypeError, "can't convert #{other.class} into #{self.class}"
         end
 
         # strip trailing zeros from commands

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

@@ -5,6 +5,8 @@ require 'set'
 require 'openhab/core/thread_local'
 require 'openhab/log/logger'
 
+require_relative 'item_event'
+
 module OpenHAB
   module DSL
     #
@@ -29,6 +31,8 @@ module OpenHAB
         # @param [Config] config Rule configuration
         #
         # Constructor sets a number of variables, no further decomposition necessary
+        # rubocop:disable Metrics/MethodLength
+        # Metrics disabled because only setters are called or defaults set.
         def initialize(config:)
           super()
           set_name(config.name)
@@ -41,7 +45,9 @@ module OpenHAB
           @between = between || OpenHAB::DSL::TimeOfDay::ALL_DAY
           # Convert between to correct range or nil if not set
           @trigger_delays = config.trigger_delays
+          @attachments = config.attachments
         end
+        # rubocop:enable Metrics/MethodLength
 
         #
         # Execute the rule
@@ -51,7 +57,7 @@ module OpenHAB
         #
         #
         def execute(mod = nil, inputs = nil)
-          logger.trace { "Execute called with mod (#{mod&.to_string}) and inputs (#{inputs&.pretty_inspect}" }
+          logger.trace { "Execute called with mod (#{mod&.to_string}) and inputs (#{inputs&.pretty_inspect})" }
           logger.trace { "Event details #{inputs['event'].pretty_inspect}" } if inputs&.key?('event')
           if trigger_delay inputs
             trigger_delay = trigger_delay(inputs)
@@ -88,6 +94,15 @@ module OpenHAB
           end
         end
 
+        #
+        # Get the trigger_id for the trigger that caused the rule creation
+        #
+        # @return [Hash] Input hash potentially containing trigger id
+        #
+        def trigger_id(inputs)
+          inputs&.keys&.grep(/\.event$/)&.first&.chomp('.event')
+        end
+
         #
         # Returns trigger delay from inputs if it exists
         #
@@ -100,7 +115,24 @@ module OpenHAB
           # ["72698819-83cb-498a-8e61-5aab8b812623.event", "oldState", "module", \
           #  "72698819-83cb-498a-8e61-5aab8b812623.oldState", "event", "newState",\
           #  "72698819-83cb-498a-8e61-5aab8b812623.newState"]
-          @trigger_delays[inputs&.keys&.grep(/\.event$/)&.first&.chomp('.event')]
+          @trigger_delays[trigger_id(inputs)]
+        end
+
+        # If an attachment exists for the trigger for this event add it to the event object
+        # @param [Object] Event
+        # @param [Hash] Inputs into event
+        # @return [Object] Event with attachment added
+        #
+        def add_attachment(event, inputs)
+          attachment = @attachments[trigger_id(inputs)]
+          return event unless attachment
+
+          # Some events, like those from cron triggers don't have an event
+          # so an event is created
+          event ||= Struct.new(:event).new
+
+          event.attachment = attachment
+          event
         end
 
         #
@@ -268,8 +300,11 @@ module OpenHAB
         # @param [Map] inputs OpenHAB map object describing rule trigge
         #
         #
+        # rubocop:disable Metrics/MethodLength
+        # No logical way to break this method up
         def process_queue(run_queue, mod, inputs)
           event = inputs&.dig('event')
+          event = add_attachment(event, inputs)
 
           while (task = run_queue.shift)
             if task.is_a? RuleConfig::Delay
@@ -281,6 +316,7 @@ module OpenHAB
         rescue StandardError => e
           print_backtrace(e)
         end
+        # rubocop:enable Metrics/MethodLength
 
         #
         # Dispatch execution block tasks to different methods

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

@@ -13,13 +13,13 @@ module OpenHAB
         include OpenHAB::DSL::Rules::Property
 
         prop_array(:only_if) do |item|
-          unless item.is_a?(Proc) || item.respond_to?(:truthy?)
+          unless item.is_a?(Proc) || [item].flatten.all? { |it| it.respond_to?(:truthy?) }
             raise ArgumentError, "Object passed to only_if must respond_to 'truthy?'"
           end
         end
 
         prop_array(:not_if) do |item|
-          unless item.is_a?(Proc) || item.respond_to?(:truthy?)
+          unless item.is_a?(Proc) || [item].flatten.all? { |it| it.respond_to?(:truthy?) }
             raise ArgumentError, "Object passed to not_if must respond_to 'truthy?'"
           end
         end
@@ -113,7 +113,7 @@ module OpenHAB
           # @return [Boolean] True if criteria are satisfied, false otherwise
           #
           def process_not_if(event, items, procs)
-            items.none?(&:truthy?) && procs.none? { |proc| proc.call(event) }
+            items.flatten.none?(&:truthy?) && procs.none? { |proc| proc.call(event) }
           end
 
           #
@@ -126,7 +126,7 @@ module OpenHAB
           # @return [Boolean] True if criteria are satisfied, false otherwise
           #
           def process_only_if(event, items, procs)
-            items.all?(&:truthy?) && procs.all? { |proc| proc.call(event) }
+            items.flatten.all?(&:truthy?) && procs.all? { |proc| proc.call(event) }
           end
         end
       end

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

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module OpenHAB
+  module DSL
+    module Rules
+      #
+      # Extends OpenHAB events
+      #
+      module Events
+        java_import org.openhab.core.events.AbstractEvent
+
+        # Add attachments to ItemEvent
+        class AbstractEvent
+          attr_accessor :attachment
+        end
+      end
+    end
+  end
+end

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

@@ -87,7 +87,7 @@ module OpenHAB
         rule = AutomationRule.new(config: config)
         Rules.script_rules << rule
         add_rule(rule)
-        rule.execute if config.on_start?
+        rule.execute(nil, { 'event' => Struct.new(:attachment).new(config.start_attachment) }) if config.on_start?
       end
 
       #

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

@@ -37,6 +37,9 @@ module OpenHAB
         # @return [Array] Of trigger delays
         attr_reader :trigger_delays
 
+        # @return [Hash] Hash of trigger UIDs to attachments
+        attr_reader :attachments
+
         # @return [Array] Of trigger guards
         attr_accessor :guard
 
@@ -82,6 +85,7 @@ module OpenHAB
         def initialize(rule_name, caller_binding)
           @triggers = []
           @trigger_delays = {}
+          @attachments = {}
           @caller = caller_binding.eval 'self'
           enabled(true)
           on_start(false)
@@ -96,8 +100,8 @@ module OpenHAB
         #
         # rubocop: disable Style/OptionalBooleanParameter
         # Disabled cop due to use in a DSL
-        def on_start(run_on_start = true)
-          @on_start = run_on_start
+        def on_start(run_on_start = true, attach: nil)
+          @on_start = Struct.new(:enabled, :attach).new(run_on_start, attach)
         end
         # rubocop: enable Style/OptionalBooleanParameter
 
@@ -107,7 +111,16 @@ module OpenHAB
         # @return [Boolean] True if rule should run on start, false otherwise.
         #
         def on_start?
-          @on_start
+          @on_start.enabled
+        end
+
+        #
+        # Get the optional start attachment
+        #
+        # @return [Object] optional user provided attachment to the on_start method
+        #
+        def start_attachment
+          @on_start.attach
         end
 
         #
@@ -144,7 +157,8 @@ module OpenHAB
             "Run blocks: (#{run}) " \
             "on_start: (#{on_start?}) " \
             "Trigger Waits: #{trigger_delays} " \
-            "Trigger UIDs: #{triggers.map(&:id).join(', ')}"
+            "Trigger UIDs: #{triggers.map(&:id).join(', ')}" \
+            "Attachments: #{attachments} "
         end
       end
     end

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

@@ -30,16 +30,16 @@ module OpenHAB
         #
         # @return [Trigger] OpenHAB trigger
         #
-        def changed(*items, to: nil, from: nil, for: nil)
+        def changed(*items, to: nil, from: nil, for: nil, attach: nil)
           separate_groups(items).map do |item|
             logger.trace("Creating changed trigger for entity(#{item}), to(#{to}), from(#{from})")
             # for is a reserved word in ruby, so use local_variable_get :for
             if (wait_duration = binding.local_variable_get(:for))
-              changed_wait(item, to: to, from: from, duration: wait_duration)
+              changed_wait(item, to: to, from: from, duration: wait_duration, attach: attach)
             else
               # Place in array and flatten to support multiple to elements or single or nil
               [to].flatten.map do |to_state|
-                [from].flatten.map { |from_state| create_changed_trigger(item, from_state, to_state) }
+                [from].flatten.map { |from_state| create_changed_trigger(item, from_state, to_state, attach) }
               end
             end
           end.flatten
@@ -57,8 +57,8 @@ module OpenHAB
         #
         # @return [Trigger] OpenHAB trigger
         #
-        def changed_wait(item, duration:, to: nil, from: nil)
-          trigger = create_changed_trigger(item, nil, nil)
+        def changed_wait(item, duration:, to: nil, from: nil, attach: nil)
+          trigger = create_changed_trigger(item, nil, nil, attach)
           logger.trace("Creating Changed Wait Change Trigger for #{item}")
           @trigger_delays[trigger.id] = TriggerDelay.new(to: to, from: from, duration: duration)
           trigger
@@ -72,14 +72,14 @@ module OpenHAB
         # @param [String] to state restrict trigger to
         #
         #
-        def create_changed_trigger(item, from, to)
+        def create_changed_trigger(item, from, to, attach)
           trigger, config = case item
                             when OpenHAB::DSL::Items::GroupItem::GroupMembers
                               create_group_changed_trigger(item, from, to)
                             when Thing then create_thing_changed_trigger(item, from, to)
                             else create_item_changed_trigger(item, from, to)
                             end
-          append_trigger(trigger, config)
+          append_trigger(trigger, config, attach: attach)
         end
 
         #

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

@@ -21,12 +21,12 @@ module OpenHAB
         # @param [String] triggered specific triggering condition to match for trigger
         #
         #
-        def channel(*channels, thing: nil, triggered: nil)
+        def channel(*channels, thing: nil, triggered: nil, attach: nil)
           channels.flatten.each do |channel|
             channel = [thing, channel].join(':') if thing
             logger.trace("Creating channel trigger for channel(#{channel}), thing(#{thing}), trigger(#{triggered})")
             [triggered].flatten.each do |trigger|
-              create_channel_trigger(channel, trigger)
+              create_channel_trigger(channel, trigger, attach)
             end
           end
         end
@@ -40,12 +40,12 @@ module OpenHAB
         # @param [Trigger] trigger specific channel trigger to match
         #
         #
-        def create_channel_trigger(channel, trigger)
+        def create_channel_trigger(channel, trigger, attach)
           config = { 'channelUID' => channel }
           config['event'] = trigger.to_s unless trigger.nil?
           config['channelUID'] = channel
           logger.trace("Creating Change Trigger for #{config}")
-          @triggers << Trigger.trigger(type: Trigger::CHANNEL_EVENT, config: config)
+          append_trigger(Trigger::CHANNEL_EVENT, config, attach: attach)
         end
       end
     end

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

@@ -21,14 +21,14 @@ module OpenHAB
         # @param [Array] commands commands to match for trigger
         #
         #
-        def received_command(*items, command: nil, commands: nil)
+        def received_command(*items, command: nil, commands: nil, attach: nil)
           separate_groups(items).map do |item|
             logger.trace("Creating received command trigger for item(#{item})"\
                          "command(#{command}) commands(#{commands})")
 
             # Combine command and commands, doing union so only a single nil will be in the combined array.
             combined_commands = combine_commands(command, commands)
-            create_received_trigger(combined_commands, item)
+            create_received_trigger(combined_commands, item, attach)
           end.flatten
         end
 
@@ -41,7 +41,7 @@ module OpenHAB
         # @param [Object] item to create trigger for
         #
         #
-        def create_received_trigger(commands, item)
+        def create_received_trigger(commands, item, attach)
           commands.map do |command|
             if item.is_a? OpenHAB::DSL::Items::GroupItem::GroupMembers
               config, trigger = create_group_command_trigger(item)
@@ -49,7 +49,7 @@ module OpenHAB
               config, trigger = create_item_command_trigger(item)
             end
             config['command'] = command.to_s unless command.nil?
-            append_trigger(trigger, config)
+            append_trigger(trigger, config, attach: attach)
           end
         end
 

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

@@ -46,9 +46,10 @@ module OpenHAB
         #
         # @return [Trigger] OpenHAB trigger
         #
-        def append_trigger(type, config)
+        def append_trigger(type, config, attach: nil)
           logger.trace("Creating trigger of type #{type} for #{config}")
           trigger = Trigger.trigger(type: type, config: config)
+          @attachments[trigger.id] = attach if attach
           @triggers << trigger
           trigger
         end

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

@@ -19,12 +19,12 @@ module OpenHAB
         #
         # @return [Trigger] Trigger for updated entity
         #
-        def updated(*items, to: nil)
+        def updated(*items, to: nil, attach: nil)
           separate_groups(items).map do |item|
             logger.trace("Creating updated trigger for item(#{item}) to(#{to})")
             [to].flatten.map do |to_state|
               trigger, config = create_update_trigger(item, to_state)
-              append_trigger(trigger, config)
+              append_trigger(trigger, config, attach: attach)
             end
           end.flatten
         end

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

@@ -161,7 +161,8 @@ module OpenHAB
             time_string = "#{time_string}T00:00:00#{zone}" if DATE_ONLY_REGEX.match?(time_string)
             self <=> DateTimeType.parse(time_string)
           elsif other.respond_to?(:coerce)
-            lhs, rhs = other.coerce(self)
+            return nil unless (lhs, rhs = other.coerce(self))
+
             lhs <=> rhs
           end
         end
@@ -179,13 +180,11 @@ module OpenHAB
         def coerce(other)
           logger.trace("Coercing #{self} as a request from #{other.class}")
           if other.is_a?(Items::DateTimeItem)
-            raise TypeError, "can't convert #{UnDefType} into #{self.class}" unless other.state?
+            return unless other.state?
 
             [other.state, self]
           elsif other.respond_to?(:to_time)
             [DateTimeType.new(other), self]
-          else
-            raise TypeError, "can't convert #{other.class} into #{self.class}"
           end
         end
 
@@ -286,8 +285,7 @@ module OpenHAB
             self + other
           elsif other.respond_to?(:to_d)
             DateTimeType.new(zoned_date_time.plusNanos((other.to_d * 1_000_000_000).to_i))
-          elsif other.respond_to?(:coerce)
-            lhs, rhs = other.coerce(to_d)
+          elsif other.respond_to?(:coerce) && (lhs, rhs = other.coerce(to_d))
             lhs + rhs
           else
             raise TypeError, "\#{other.class} can't be coerced into \#{self.class}"
@@ -320,8 +318,7 @@ module OpenHAB
             self - other
           elsif other.respond_to?(:to_d)
             DateTimeType.new(zoned_date_time.minusNanos((other.to_d * 1_000_000_000).to_i))
-          elsif other.respond_to?(:coerce)
-            lhs, rhs = other.coerce(to_d)
+          elsif other.respond_to?(:coerce) && (lhs, rhs = other.coerce(to_d))
             lhs - rhs
           else
             raise TypeError, "\#{other.class} can't be coerced into \#{self.class}"

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

@@ -87,7 +87,8 @@ module OpenHAB
           elsif other.respond_to?(:to_d)
             to_d <=> other.to_d
           elsif other.respond_to?(:coerce)
-            lhs, rhs = other.coerce(self)
+            return nil unless (lhs, rhs = other.coerce(self))
+
             lhs <=> rhs
           end
         end
@@ -109,15 +110,13 @@ module OpenHAB
           logger.trace("Coercing #{self} as a request from #{other.class}")
           if other.is_a?(Items::NumericItem) ||
              (other.is_a?(Items::GroupItem) && other.base_item.is_a?(Items::NumericItem))
-            raise TypeError, "can't convert #{UnDefType} into #{self.class}" unless other.state?
+            return unless other.state?
 
             [other.state, self]
           elsif other.is_a?(Type)
             [other, as(other.class)]
           elsif other.respond_to?(:to_d)
             [self.class.new(other.to_d), self]
-          else
-            raise TypeError, "can't convert #{other.class} into #{self.class}"
           end
         end
 
@@ -150,8 +149,7 @@ module OpenHAB
             #     # result could already be a QuantityType
             #     result = self.class.new(result) unless result.is_a?(NumericType)
             #     result
-            #   elsif other.respond_to?(:coerce)
-            #     lhs, rhs = other.coerce(to_d)
+            #   elsif other.respond_to?(:coerce) && (lhs, rhs = other.coerce(to_d))
             #     lhs + rhs
             #   else
             #     raise TypeError, "#{other.class} can't be coerced into #{self.class}"
@@ -168,8 +166,7 @@ module OpenHAB
                   # result could already be a QuantityType
                   result = self.class.new(result) unless result.is_a?(NumericType)
                   result
-                elsif other.respond_to?(:coerce)
-                  lhs, rhs = other.coerce(to_d)
+                elsif other.respond_to?(:coerce) && (lhs, rhs = other.coerce(to_d))
                   lhs #{ruby_op} rhs
                 else
                   raise TypeError, "\#{other.class} can't be coerced into \#{self.class}"

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

@@ -133,7 +133,7 @@ module OpenHAB
           logger.trace("Coercing #{self} as a request from #{other.class}")
           if other.is_a?(Items::NumericItem) ||
              (other.is_a?(Items::GroupItem) && other.base_item.is_a?(Items::NumericItem))
-            raise TypeError, "can't convert #{UnDefType} into #{self.class}" unless other.state?
+            return unless other.state?
 
             [other.state, self]
           elsif other.respond_to?(:to_str)

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

@@ -64,7 +64,8 @@ module OpenHAB
           elsif other.respond_to?(:to_str)
             self == PointType.new(other)
           elsif other.respond_to?(:coerce)
-            lhs, rhs = other.coerce(self)
+            return false unless (lhs, rhs = other.coerce(self))
+
             lhs == rhs
           end
         end
@@ -80,7 +81,10 @@ module OpenHAB
         # @return [[PointType, PointType]]
         #
         def coerce(other)
-          [coerce_single(other), self]
+          lhs = coerce_single(other)
+          return unless lhs
+
+          [lhs, self]
         end
 
         # rename raw methods so we can overwrite them
@@ -123,7 +127,10 @@ module OpenHAB
         # @return [QuantityType]
         def distance_from(other)
           logger.trace("(#{self}).distance_from(#{other} (#{other.class})")
-          QuantityType.new(raw_distance_from(coerce_single(other)), SIUnits::METRE)
+          other = coerce_single(other)
+          raise TypeError, "#{other.class} can't be coerced into #{self.class}" unless other
+
+          QuantityType.new(raw_distance_from(other), SIUnits::METRE)
         end
         alias - distance_from
 
@@ -131,18 +138,16 @@ module OpenHAB
 
         # coerce an object to a PointType
         # @return [PointType]
-        def coerce_single(other) # rubocop:disable Metrics/MethodLength
+        def coerce_single(other)
           logger.trace("Coercing #{self} as a request from #{other.class}")
           if other.is_a?(PointType)
             other
           elsif other.is_a?(Items::LocationItem)
-            raise TypeError, "can't convert #{other.raw_state} into #{self.class}" unless other.state?
+            return unless other.state?
 
             other.state
           elsif other.respond_to?(:to_str)
             PointType.new(other.to_str)
-          else
-            raise TypeError, "can't convert #{other.class} into #{self.class}"
           end
         end
       end

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

@@ -61,7 +61,8 @@ module OpenHAB
           elsif other.respond_to?(:to_d)
             compare_to(QuantityType.new(other.to_d.to_java, Units.unit || unit))
           elsif other.respond_to?(:coerce)
-            lhs, rhs = other.coerce(self)
+            return nil unless (lhs, rhs = other.coerce(self))
+
             lhs <=> rhs
           end
         end
@@ -82,7 +83,7 @@ module OpenHAB
           logger.trace("Coercing #{self} as a request from #{other.class}")
           if other.is_a?(Items::NumericItem) ||
              (other.is_a?(Items::GroupItem) && other.base_item.is_a?(Items::NumericItem))
-            raise TypeError, "can't convert #{UnDefType} into #{self.class}" unless other.state?
+            return unless other.state?
 
             [other.state, self]
           elsif other.is_a?(Type)
@@ -91,8 +92,6 @@ module OpenHAB
             [QuantityType.new(other.to_d.to_java, ONE), self]
           elsif other.is_a?(String)
             [QuantityType.new(other), self]
-          else
-            raise TypeError, "can't convert #{other.class} into #{self.class}"
           end
         end
 
@@ -123,9 +122,8 @@ module OpenHAB
             #   elsif other.respond_to?(:to_d)
             #     other = other.to_d.to_java
             #     add_quantity(self.class.new(other, Units.unit || unit))
-            #   elsif other.respond_to?(:coerce)
-            #     lhs, rhs = other.coerce(to_d)
-            #     lhs = rhs
+            #   elsif other.respond_to?(:coerce) && (lhs, rhs = other.coerce(to_d))
+            #     lhs + rhs
             #   else
             #     raise TypeError, "#{other.class} can't be coerced into #{self.class}"
             #   end
@@ -148,8 +146,7 @@ module OpenHAB
                 elsif other.respond_to?(:to_d)
                   other = other.to_d.to_java
                   #{java_op}_quantity(#{convert})
-                elsif other.respond_to?(:coerce)
-                  lhs, rhs = other.coerce(to_d)
+                elsif other.respond_to?(:coerce) && (lhs, rhs = other.coerce(to_d))
                   lhs #{ruby_op} rhs
                 else
                   raise TypeError, "\#{other.class} can't be coerced into \#{self.class}"
@@ -179,8 +176,7 @@ module OpenHAB
             #     self * self.class.new(other)
             #   elsif other.respond_to?(:to_d)
             #     multiply(other.to_d.to_java)
-            #   elsif other.respond_to?(:coerce)
-            #     lhs, rhs = other.coerce(to_d)
+            #   elsif other.respond_to?(:coerce) && (lhs, rhs = other.coerce(to_d))
             #     lhs * rhs
             #   else
             #     raise TypeError, "#{other.class} can't be coerced into #{self.class}"
@@ -202,8 +198,7 @@ module OpenHAB
                   self #{ruby_op} self.class.new(other)
                 elsif other.respond_to?(:to_d)
                   #{java_op}(other.to_d.to_java)
-                elsif other.respond_to?(:coerce)
-                  lhs, rhs = other.coerce(to_d)
+                elsif other.respond_to?(:coerce) && (lhs, rhs = other.coerce(to_d))
                   lhs #{ruby_op} rhs
                 else
                   raise TypeError, "\#{other.class} can't be coerced into \#{self.class}"

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

@@ -52,7 +52,8 @@ module OpenHAB
           elsif other.respond_to?(:to_str)
             to_str <=> other.to_str
           elsif other.respond_to?(:coerce)
-            lhs, rhs = other.coerce(self)
+            return nil unless (lhs, rhs = other.coerce(self))
+
             lhs <=> rhs
           end
         end
@@ -70,13 +71,11 @@ module OpenHAB
         def coerce(other)
           logger.trace("Coercing #{self} as a request from #{other.class}")
           if other.is_a?(Items::StringItem)
-            raise TypeError, "can't convert #{other.raw_state} into #{self.class}" unless other.state?
+            return unless other.state?
 
             [other.state, self]
           elsif other.respond_to?(:to_str)
             [String.new(other.to_str), self]
-          else
-            raise TypeError, "can't convert #{other.class} into #{self.class}"
           end
         end
 

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

@@ -28,8 +28,6 @@ module OpenHAB
         def coerce(other)
           logger.trace("Coercing #{self} (#{self.class}) as a request from #{other.class}")
           return [other.as(self.class), self] if other.is_a?(Type)
-
-          raise TypeError, "can't convert #{other.class} into #{self.class}"
         end
 
         #
@@ -49,7 +47,8 @@ module OpenHAB
         # @return [Boolean] if the same value is represented, including
         #   type conversions
         #
-        def ==(other)
+        def ==(other) # rubocop:disable Metrics
+          logger.trace("(#{self.class}) #{self} == #{other} (#{other.class})")
           return true if equal?(other)
 
           # i.e. ON == OFF, REFRESH == ON, ON == REFRESH
@@ -60,7 +59,17 @@ module OpenHAB
           return self == other.raw_state if other.is_a?(Items::GenericItem)
 
           if other.respond_to?(:coerce)
-            lhs, rhs = other.coerce(self)
+            begin
+              return false unless (lhs, rhs = other.coerce(self))
+            rescue TypeError
+              # this one is a bit odd. 50 (Integer) == ON is internally
+              # flipping the argument and calling this method. but it responds
+              # to coerce, and then raises a TypeError (from Float???) that
+              # it couldn't convert to OnOffType. it probably should have
+              # returned nil. catch it and return false instead
+              return false
+            end
+
             return lhs == rhs
           end
 

data/lib/openhab/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: openhab-scripting
 version: !ruby/object:Gem::Version
-  version: 4.8.5
+  version: 4.10.2
 platform: ruby
 authors:
 - Brian O'Connell
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2021-11-01 00:00:00.000000000 Z
+date: 2021-11-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -93,6 +93,7 @@ files:
 - lib/openhab/dsl/persistence.rb
 - lib/openhab/dsl/rules/automation_rule.rb
 - lib/openhab/dsl/rules/guard.rb
+- lib/openhab/dsl/rules/item_event.rb
 - lib/openhab/dsl/rules/property.rb
 - lib/openhab/dsl/rules/rule.rb
 - lib/openhab/dsl/rules/rule_config.rb