openhab-scripting 4.10.0 → 4.11.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 14f2ced679ac7bcaa331235fa8e86156b7c25d106628047f36d8bbd8c1ee2e0d
-  data.tar.gz: 164856fab952fec915c2e562b1ef7da5e545a560efb2001e286360d6b558da14
+  metadata.gz: 7f4fc0e817de7a0a8ef1892e7e397552afb897bc45983935a73ab39f03975733
+  data.tar.gz: 756291721126083940a335788551a7d1bafdd7643b0bd4cd5cb3bedb7b576ae0
 SHA512:
-  metadata.gz: 4d79581b46aa3606f63e79a7cc3a2ece846506f90c244a554df236bde8feb9f46067de014bbbff7639436716ec95b040949f632b60ecd86fc7580cc387039fe5
-  data.tar.gz: 2c3f012ee50964c35c6996253fb5001b1253c4cf155f5d677174ba16ff765e8f4982a90bd9907876883d37702d0b2b8ff6c76c37d362f05df4c21c82218456f5
+  metadata.gz: 58b0de14c919cdc09bef1d8f37c782052a8a36740feddf797e2a8d38a112b334d795a270b757dbae3938269faf29b117aceb303de2c3878da608214aeb25e7fc
+  data.tar.gz: a0079a59f25d709814f20527045d7b7c57f4b7c702f3618c616be56117e60b7e0920d023d19d2752556f41f2a85b3e617280e00176a2d60513bef07a0067e882

data/lib/openhab/dsl/between.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require_relative 'time/time_of_day'
+require_relative 'time/month_day'
+
+module OpenHAB
+  module DSL
+    # Supports between range syntax
+    module Between
+      # Creates a range that can be compared against time of day/month days or strings
+      # to see if they are within the range
+      # @since 2.4.0
+      # @return Range object representing a TimeOfDay Range
+      def between(range)
+        raise ArgumentError, 'Supplied object must be a range' unless range.is_a? Range
+
+        return OpenHAB::DSL::Between::MonthDayRange.range(range) if OpenHAB::DSL::Between::MonthDayRange.range?(range)
+
+        OpenHAB::DSL::Between::TimeOfDay.between(range)
+      end
+    end
+  end
+end

data/lib/openhab/dsl/dsl.rb

@@ -15,7 +15,7 @@ require 'openhab/dsl/actions'
 require 'openhab/dsl/timers'
 require 'openhab/dsl/group'
 require 'openhab/dsl/things'
-require 'openhab/dsl/time_of_day'
+require 'openhab/dsl/between'
 require 'openhab/dsl/gems'
 require 'openhab/dsl/persistence'
 require 'openhab/dsl/units'
@@ -31,6 +31,7 @@ module OpenHAB
     # rubocop:disable Metrics/MethodLength
     def self.extended(base)
       base.send :include, OpenHAB::DSL::Actions
+      base.send :include, OpenHAB::DSL::Between
       base.send :include, OpenHAB::DSL::Groups
       base.send :include, OpenHAB::DSL::Items
       base.send :include, OpenHAB::DSL::Persistence
@@ -39,7 +40,7 @@ module OpenHAB
       base.send :include, OpenHAB::DSL::States
       base.send :include, OpenHAB::DSL::Things
       base.send :include, OpenHAB::DSL::Timers
-      base.send :include, OpenHAB::DSL::TimeOfDay
+      base.send :include, OpenHAB::DSL::Between
       base.send :include, OpenHAB::DSL::Types
       base.send :include, OpenHAB::DSL::Units
     end

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/dimmer_item.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require 'openhab/dsl/time_of_day'
-
 require_relative 'numeric_item'
 
 module OpenHAB

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

@@ -4,6 +4,7 @@ require 'java'
 require 'set'
 require 'openhab/core/thread_local'
 require 'openhab/log/logger'
+require 'openhab/dsl/between'
 
 require_relative 'item_event'
 
@@ -22,7 +23,7 @@ module OpenHAB
       class AutomationRule < Java::OrgOpenhabCoreAutomationModuleScriptRulesupportSharedSimple::SimpleRule
         include OpenHAB::Log
         include OpenHAB::Core::ThreadLocal
-        include OpenHAB::DSL::TimeOfDay
+        include OpenHAB::DSL::Between
         java_import java.time.ZonedDateTime
 
         #
@@ -42,7 +43,7 @@ module OpenHAB
           @run_queue = config.run
           @guard = config.guard
           between = config.between&.yield_self { between(config.between) }
-          @between = between || OpenHAB::DSL::TimeOfDay::ALL_DAY
+          @between = between || OpenHAB::DSL::Between::ALL_DAY
           # Convert between to correct range or nil if not set
           @trigger_delays = config.trigger_delays
           @attachments = config.attachments

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

@@ -10,7 +10,7 @@ require 'openhab/dsl/rules/triggers/command'
 require 'openhab/dsl/rules/triggers/updated'
 require 'openhab/dsl/rules/guard'
 require 'openhab/core/entity_lookup'
-require 'openhab/dsl/time_of_day'
+require 'openhab/dsl/between'
 require 'openhab/dsl/dsl'
 require 'openhab/dsl/timers'
 

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

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require 'java'
-require 'openhab/dsl/time_of_day'
 
 module OpenHAB
   module DSL

data/lib/openhab/dsl/time/month_day.rb

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+module OpenHAB
+  module DSL
+    # Support for time related functions
+    module Between
+      # Manages Month Day Ranges
+      module MonthDayRange
+        include OpenHAB::Log
+
+        java_import java.time.Year
+
+        # Lambdas are used to calculate the year for the month day
+        # which must happen during evaluation time to support that rules
+        # creation and evaluation for execution are done in distinct phases
+        @current_year = -> { return Year.now }
+        @next_year = -> { return Year.now.plus_years(1) }
+
+        class << self
+          attr_reader :current_year, :next_year
+        end
+
+        # Creates a range that can be compared against MonthDay objects, strings
+        # or anything responding to 'to_date' to see if they are within the range
+        # @return Range object representing a MonthDay Range
+        # rubocop:disable Metrics/AbcSize
+        # Range method cannot be broken up cleaner
+        def self.range(range)
+          logger.trace "Creating MonthDay range from #{range}"
+          raise ArgumentError, 'Supplied object must be a range' unless range.is_a? Range
+
+          start = MonthDay.parse(range.begin)
+          ending = MonthDay.parse(range.end)
+
+          logger.trace "Month Day Range Start(#{start}) - End (#{ending})"
+
+          # Wrap to next year if ending day of month is before starting day of month
+          ending_year = ending < start ? next_year : current_year
+
+          start_range = MonthDayRangeElement.new(month_day: start, year: current_year)
+          ending_range = MonthDayRangeElement.new(month_day: ending, year: ending_year)
+          range.exclude_end? ? (start_range...ending_range) : (start_range..ending_range)
+        end
+        # rubocop:enable Metrics/AbcSize
+
+        # Checks if supplied range can be converted to a month day range
+        # @param [Range] range to check begin and end values of
+        # @return [Boolean] Returns true if supplied range can be converted to a month day range
+        def self.range?(range)
+          return false unless range.is_a? Range
+
+          MonthDay.day_of_month?(range.begin) && MonthDay.day_of_month?(range.end)
+        end
+
+        # Represents a range element for a MonthDay object
+        # The LocalDate (MonthDay + Year) is dynamically calculated to allow for
+        # being used as a guard during rule evaluation
+        class MonthDayRangeElement
+          include Comparable
+          include OpenHAB::Log
+          java_import java.time.LocalDate
+          java_import java.time.Year
+
+          # Create a new MonthDayRange element
+          # @param [MonthDay] MonthDay element
+          # @param [Lambda] year lambda to calculate year to convert MonthDay to LocalDate
+          #
+          def initialize(month_day:, year:)
+            @month_day = month_day
+            @year = year
+          end
+
+          # Convert into a LocalDate using year lambda supplied in initializer
+          def to_local_date
+            @year.call.at_month_day(@month_day)
+          end
+
+          # Returns the MonthDay advanced by 1 day
+          # Required by Range class
+          def succ
+            next_date = to_local_date.plus_days(1)
+            # Handle rollover to next year
+            year = -> { Year.from(next_date) }
+            MonthDayRangeElement.new(month_day: MonthDay.from(next_date), year: year)
+          end
+
+          # Compare MonthDayRangeElement to other objects as required by Range class
+          # rubocop:disable Metrics/AbcSize
+          # Case statement needs to work against multiple types
+          def <=>(other)
+            case other
+            when LocalDate then to_local_date.compare_to(other)
+            when Date then self.<=>(LocalDate.of(other.year, other.month, other.day))
+            when MonthDay then self.<=>(MonthDayRange.current_year.call.at_month_day(other))
+            else
+              return self.<=>(other.to_local_date) if other.respond_to? :to_local_date
+              return self.<=>(other.to_date) if other.respond_to? :to_date
+
+              raise "Unable to convert #{other.class} to compare to MonthDay"
+            end
+          end
+          # rubocop:enable Metrics/AbcSize
+        end
+      end
+
+      java_import java.time.MonthDay
+      # Extend MonthDay java object with some helper methods
+      class MonthDay
+        include OpenHAB::Log
+        # Parse MonthDay string as defined with by Monthday class without leading double dash "--"
+        def self.parse(string)
+          ##          string = "--#{string}" unless string.to_s.start_with? '--'
+          java_send :parse, [java.lang.CharSequence], "--#{string}"
+        end
+
+        # Can the supplied object be parsed into a MonthDay
+        def self.day_of_month?(obj)
+          /^-*[01][0-9]-[0-3]\d$/.match? obj.to_s
+        end
+
+        # Remove -- from MonthDay string representation
+        def to_s
+          to_string.delete_prefix('--')
+        end
+
+        # Extends MonthDay comparison to support Strings
+        # Necessary to support mixed ranges of Strings and MonthDay types
+        # @return [Number, nil] -1,0,1 if other MonthDay is less than, equal to, or greater than this MonthDay
+        def <=>(other)
+          case other
+          when String
+            self.<=>(MonthDay.parse(other))
+          else
+            super
+          end
+        end
+      end
+    end
+  end
+end

data/lib/openhab/dsl/{time_of_day.rb → time/time_of_day.rb}

@@ -10,7 +10,7 @@ module OpenHAB
     # Times without specific dates e.g. 6:00:00
     # @author Brian O'Connell
     # @since 0.0.1
-    module TimeOfDay
+    module Between
       java_import java.time.LocalTime
       java_import java.time.format.DateTimeFormatterBuilder
       java_import java.util.Locale
@@ -123,6 +123,41 @@ module OpenHAB
             -(other <=> self)
           end
         end
+
+        # Creates a range that can be compared against time of day objects or strings
+        # to see if they are within the range
+        # @since 2.4.0
+        # @return Range object representing a TimeOfDay Range
+        def self.between(range)
+          raise ArgumentError, 'Supplied object must be a range' unless range.is_a? Range
+
+          start = to_time_of_day(range.begin)
+          ending = to_time_of_day(range.end)
+
+          start_sod = start.local_time.to_second_of_day
+          ending_sod = ending.local_time.to_second_of_day
+          ending_sod += TimeOfDayRangeElement::NUM_SECONDS_IN_DAY if ending_sod < start_sod
+
+          start_range = TimeOfDayRangeElement.new(sod: start_sod, range_begin: start_sod)
+          ending_range = TimeOfDayRangeElement.new(sod: ending_sod, range_begin: start_sod)
+          range.exclude_end? ? (start_range...ending_range) : (start_range..ending_range)
+        end
+
+        #
+        # Convert object to TimeOfDay object
+        #
+        # @param [Object] object TimeOfDay or String to be converted
+        #
+        # @return [TimeOfDay] TimeOfDay created from supplied object
+        #
+        def self.to_time_of_day(object)
+          case object
+          when String then TimeOfDay.parse(object)
+          when Time, OpenHAB::DSL::Types::DateTimeType, OpenHAB::DSL::Items::DateTimeItem
+            TimeOfDay.new(h: object.hour, m: object.min, s: object.sec)
+          else object
+          end
+        end
       end
 
       # Modules that refines the Ruby Range object cover? and include? methods to support TimeOfDay ranges
@@ -168,17 +203,20 @@ module OpenHAB
         #
         # @return [Integer] seconds of day represented by supplied object
         #
+        # rubocop:disable Metrics/AbcSize
+        # case statement needs to compare against multiple types
         def to_second_of_day(object)
           case object
           when TimeOfDay then adjust_second_of_day(object.local_time.to_second_of_day)
           when String then adjust_second_of_day(TimeOfDay.parse(object).local_time.to_second_of_day)
-          when Time, OpenHAB::DSL::Types::DateTimeType, OpenHAB::DSL::Items::DateTimeItem
+          when ::Time, OpenHAB::DSL::Types::DateTimeType, OpenHAB::DSL::Items::DateTimeItem
             adjust_second_of_day(TimeOfDay.new(h: object.hour, m: object.min, s: object.sec)
             .local_time.to_second_of_day)
           when TimeOfDayRangeElement then object.sod
-          else raise ArgumentError, 'Supplied argument cannot be converted into Time Of Day Object'
+          else raise ArgumentError, "Supplied argument #{object.class} cannot be converted into Time Of Day Object"
           end
         end
+        # rubocop:enable Metrics/AbcSize
 
         def adjust_second_of_day(second_of_day)
           second_of_day += NUM_SECONDS_IN_DAY if second_of_day < @range_begin
@@ -186,46 +224,9 @@ module OpenHAB
         end
       end
 
-      # Creates a range that can be compared against time of day objects or strings
-      # to see if they are within the range
-      # @since 2.4.0
-      # @return Range object representing a TimeOfDay Range
-      module_function
-
-      def between(range)
-        raise ArgumentError, 'Supplied object must be a range' unless range.is_a? Range
-
-        start = to_time_of_day(range.begin)
-        ending = to_time_of_day(range.end)
-
-        start_sod = start.local_time.to_second_of_day
-        ending_sod = ending.local_time.to_second_of_day
-        ending_sod += TimeOfDayRangeElement::NUM_SECONDS_IN_DAY if ending_sod < start_sod
-
-        start_range = TimeOfDayRangeElement.new(sod: start_sod, range_begin: start_sod)
-        ending_range = TimeOfDayRangeElement.new(sod: ending_sod, range_begin: start_sod)
-        range.exclude_end? ? (start_range...ending_range) : (start_range..ending_range)
-      end
-
-      #
-      # Convert object to TimeOfDay object
-      #
-      # @param [Object] object TimeOfDay or String to be converted
-      #
-      # @return [TimeOfDay] TimeOfDay created from supplied object
-      #
-      private_class_method def to_time_of_day(object)
-        case object
-        when String then TimeOfDay.parse(object)
-        when Time, OpenHAB::DSL::Types::DateTimeType, OpenHAB::DSL::Items::DateTimeItem
-          TimeOfDay.new(h: object.hour, m: object.min, s: object.sec)
-        else object
-        end
-      end
-
       MIDNIGHT = TimeOfDay.midnight
       NOON = TimeOfDay.noon
-      ALL_DAY = between(TimeOfDay.new(h: 0, m: 0, s: 0)..TimeOfDay.new(h: 23, m: 59, s: 59))
+      ALL_DAY = TimeOfDay.between(TimeOfDay.new(h: 0, m: 0, s: 0)..TimeOfDay.new(h: 23, m: 59, s: 59))
     end
   end
 end

data/lib/openhab/dsl/timers/timer.rb

@@ -59,6 +59,10 @@ module OpenHAB
         # @return [Timer] Rescheduled timer instances
         #
         def reschedule(duration = nil)
+          unless duration.nil? || duration.is_a?(Java::JavaTimeTemporal::TemporalAmount)
+            raise ArgumentError, 'Supplied argument must be a duration'
+          end
+
           duration ||= @duration
           Timers.timer_manager.add(self)
           @timer.reschedule(ZonedDateTime.now.plus(duration))

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

@@ -59,7 +59,7 @@ module OpenHAB
           rescue java.lang.StringIndexOutOfBoundsException, java.lang.IllegalArgumentException
             # Try ruby's Time.parse if OpenHAB's DateTimeType parser fails
             begin
-              DateTimeType.new(Time.parse(time_string))
+              DateTimeType.new(::Time.parse(time_string))
             rescue ArgumentError
               raise ArgumentError, "Unable to parse #{time_string} into a DateTimeType"
             end
@@ -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
 
@@ -195,7 +194,7 @@ module OpenHAB
         # @return [Time] A Time object representing the same instant and timezone
         #
         def to_time
-          Time.at(to_i, nsec, :nsec).localtime(utc_offset)
+          ::Time.at(to_i, nsec, :nsec).localtime(utc_offset)
         end
 
         #
@@ -257,7 +256,7 @@ module OpenHAB
         # @!visibility private
         def respond_to_missing?(method, _include_private = false)
           return true if zoned_date_time.respond_to?(method)
-          return true if Time.instance_methods.include?(method.to_sym)
+          return true if ::Time.instance_methods.include?(method.to_sym)
 
           super
         end
@@ -268,7 +267,7 @@ module OpenHAB
         #
         def method_missing(method, *args, &block)
           return zoned_date_time.send(method, *args, &block) if zoned_date_time.respond_to?(method)
-          return to_time.send(method, *args, &block) if Time.instance_methods.include?(method.to_sym)
+          return to_time.send(method, *args, &block) if ::Time.instance_methods.include?(method.to_sym)
 
           super
         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.10.0'
+  VERSION = '4.11.0'
 end

data/lib/openhab.rb

@@ -19,7 +19,6 @@ module OpenHAB
   # @param [Object] base Object to decorate with DSL and helper methods
   #
   #
-  # rubocop:disable  Metrics/MethodLength
   # Number of extensions and includes requires more lines
   def self.extended(base)
     OpenHAB::Core.wait_till_openhab_ready
@@ -27,16 +26,14 @@ module OpenHAB
     base.extend OpenHAB::Core::ScriptHandling
     base.extend OpenHAB::Core::EntityLookup
     base.extend OpenHAB::DSL
-    base.extend OpenHAB::DSL::TimeOfDay
+    base.extend OpenHAB::DSL::Between
 
-    base.send :include, OpenHAB::DSL::TimeOfDay
     base.send :include, OpenHAB::DSL::Items
     base.send :include, OpenHAB::DSL::Types
     logger.info "OpenHAB JRuby Scripting Library Version #{OpenHAB::VERSION} Loaded"
 
     OpenHAB::Core.add_rubylib_to_load_path
   end
-  # rubocop:enable  Metrics/MethodLength
 end
 
 # Extend caller with OpenHAB methods

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: openhab-scripting
 version: !ruby/object:Gem::Version
-  version: 4.10.0
+  version: 4.11.0
 platform: ruby
 authors:
 - Brian O'Connell
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2021-11-02 00:00:00.000000000 Z
+date: 2021-11-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -53,6 +53,7 @@ files:
 - lib/openhab/core/script_handling.rb
 - lib/openhab/core/thread_local.rb
 - lib/openhab/dsl/actions.rb
+- lib/openhab/dsl/between.rb
 - lib/openhab/dsl/dsl.rb
 - lib/openhab/dsl/gems.rb
 - lib/openhab/dsl/group.rb
@@ -106,7 +107,8 @@ files:
 - lib/openhab/dsl/rules/triggers/updated.rb
 - lib/openhab/dsl/states.rb
 - lib/openhab/dsl/things.rb
-- lib/openhab/dsl/time_of_day.rb
+- lib/openhab/dsl/time/month_day.rb
+- lib/openhab/dsl/time/time_of_day.rb
 - lib/openhab/dsl/timers.rb
 - lib/openhab/dsl/timers/manager.rb
 - lib/openhab/dsl/timers/reentrant_timer.rb