openhab-jrubyscripting 5.0.0.rc11 → 5.0.0.rc.13

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

@@ -110,20 +110,15 @@ module OpenHAB
         #
         # Coerce object to a {DecimalType DecimalType}
         #
-        # @param [Numeric, Type] other object to coerce to a {DecimalType DecimalType}
-        #
-        #   If `other` is a {Type}, `self` will instead be coerced
-        #   to that type to accomodate comparison with things such as {OnOffType}.
+        # @param [Numeric] other object to coerce to a {DecimalType DecimalType}
         #
         # @return [Array<(DecimalType, DecimalType)>, nil]
         #
         def coerce(other)
           logger.trace("Coercing #{self} as a request from #{other.class}")
-          if other.is_a?(Type)
-            [other, as(other.class)]
-          elsif other.respond_to?(:to_d)
-            [self.class.new(other.to_d), self]
-          end
+          return unless other.respond_to?(:to_d)
+
+          [self.class.new(other.to_d), self]
         end
 
         #

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

@@ -142,7 +142,7 @@ module OpenHAB
         end
 
         # Convert to an HTML-style string of 6 hex characters in the default sRGB color model.
-        # @return [String] +'#xxxxxx'+
+        # @return [String] `"#xxxxxx"`
         def to_hex
           Kernel.format("#%06x", rgb)
         end
@@ -174,7 +174,7 @@ module OpenHAB
 
         # @!method to_xy
         #   Convert to the xyY values representing this object's color in CIE XY color model
-        #   @return [[PercentType, PercentType]]
+        #   @return [[PercentType, PercentType, PercentType]]
       end
     end
   end

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

@@ -157,19 +157,14 @@ module OpenHAB
         #
         # Coerce object to a {QuantityType}
         #
-        # @param [Numeric, Type] other object to coerce to a {QuantityType}
-        #
-        #   if `other` is a {Type}, `self` will instead be coerced
-        #   to that type to accomodate comparison with things such as {OnOffType}
+        # @param [Numeric] other object to coerce to a {QuantityType}
         #
         # @return [Array<(QuantityType, QuantityType)>, nil]
         def coerce(other)
           logger.trace("Coercing #{self} as a request from #{other.class}")
-          if other.is_a?(Type)
-            [other, as(other.class)]
-          elsif other.respond_to?(:to_d)
-            [QuantityType.new(other.to_d.to_java, Units::ONE), self]
-          end
+          return unless other.respond_to?(:to_d)
+
+          [QuantityType.new(other.to_d.to_java, Units::ONE), self]
         end
 
         # arithmetic operators

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

@@ -63,7 +63,7 @@ module OpenHAB
         #
         def coerce(other)
           logger.trace("Coercing #{self} as a request from #{other.class}")
-          return [String.new(other.to_str), self] if other.respond_to?(:to_str)
+          return [other.to_str, self] if other.respond_to?(:to_str)
         end
 
         # any method that exists on String gets forwarded to to_s

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

@@ -25,21 +25,6 @@ module OpenHAB
           to_s
         end
 
-        #
-        # Type Coercion
-        #
-        # Coerce object to the same Type
-        #
-        # @param [Type] other object to coerce to the same
-        #   Type as this one
-        #
-        # @return [[Type, Type], nil]
-        #
-        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) && other.respond_to?(:as)
-        end
-
         #
         # Check equality without type conversion
         #
@@ -51,19 +36,6 @@ module OpenHAB
           equals(other)
         end
 
-        #
-        # Case equality
-        #
-        # @return [true,false] if the values are of the same Type
-        #                   or item state of the same type
-        #
-        def ===(other)
-          logger.trace { "Type (#{self.class}) #{self} === #{other} (#{other.class})" }
-          return false unless instance_of?(other.class)
-
-          eql?(other)
-        end
-
         #
         # Check equality, including type conversion
         #
@@ -95,6 +67,14 @@ module OpenHAB
 
           super
         end
+
+        # @!visibility private
+        #
+        # some openHAB Types don't implement as; do it for them
+        #
+        def as(klass)
+          self if klass == self.class
+        end
       end
 
       #

data/lib/openhab/core/types.rb

@@ -57,11 +57,24 @@ module OpenHAB
           ([command] | states).each do |method|
             logger.trace("Defining #{klass}##{method} for #{value}")
             klass.class_eval <<~RUBY, __FILE__, __LINE__ + 1
-              def #{method}       # def on?
-                self == #{value}  #   self == ON
-              end                 # end
+              def #{method}                                                 # def on?
+                as(#{value.class.java_class.simple_name}).equal?(#{value})  #   as(OnOffType).equal?(ON)
+              end                                                           # end
             RUBY
           end
+
+          method = states.last
+          Events::ItemState.class_eval <<~RUBY, __FILE__, __LINE__ + 1
+            def #{method}                                                            # def on?
+              item_state.as(#{value.class.java_class.simple_name}).equal?(#{value})  #   item_state.as(OnOffType).equal?(ON)
+            end                                                                      # end
+          RUBY
+
+          Events::ItemStateChangedEvent.class_eval <<~RUBY, __FILE__, __LINE__ + 1
+            def was_#{method}                                                            # def was_on?
+              old_item_state.as(#{value.class.java_class.simple_name}).equal?(#{value})  #   old_item_state.as(OnOffType).equal?(ON)
+            end                                                                          # end
+          RUBY
         end
       end
     end

data/lib/openhab/core.rb

@@ -3,12 +3,12 @@
 module OpenHAB
   # Contains classes and modules that wrap actual openHAB objects
   module Core
-    # The openHAB Version. >= 3.3.0 is required.
+    # The openHAB Version. >= 3.4.0 is required.
     # @return [String]
     VERSION = org.openhab.core.OpenHAB.version.freeze
 
-    unless Gem::Version.new(VERSION) >= Gem::Version.new("3.3.0")
-      raise "`openhab-jrubyscripting` requires openHAB >= 3.3.0"
+    unless Gem::Version.new(VERSION) >= Gem::Version.new("3.4.0")
+      raise "`openhab-jrubyscripting` requires openHAB >= 3.4.0"
     end
 
     # @return [Integer] Number of seconds to wait between checks for automation manager

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

@@ -52,6 +52,8 @@ module OpenHAB
           return to_f <=> other if other.is_a?(Numeric)
 
           super
+        rescue TypeError
+          nil
         end
 
         #

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

@@ -7,16 +7,24 @@ module OpenHAB
     module Java
       java_import java.time.LocalDate
 
-      # Extensions to LocalDate
+      # Extensions to {java.time.LocalDate}
       class LocalDate
         include Time
         include Between
         include Ephemeris
 
-        class << self # rubocop:disable Lint/EmptyClass
-          # @!attribute [r] now
-          #   @return [ZonedDateTime]
-        end
+        # @!scope class
+
+        # @!attribute [r] now
+        #   @return [LocalDate]
+
+        # @!method parse(text, formatter=nil)
+        #   Converts the given text into a LocalDate.
+        #   @param [String] text The text to parse
+        #   @param [java.time.format.DateTimeFormatter] formatter The formatter to use
+        #   @return [LocalDate]
+
+        # @!scope instance
 
         # @param [TemporalAmount, LocalDate, Numeric] other
         #   If other is a Numeric, it's interpreted as days.
@@ -25,11 +33,11 @@ module OpenHAB
         def -(other)
           case other
           when Date
-            Period.of_days(day_of_year - other.yday)
+            self - other.to_local_date
           when MonthDay
             self - other.at_year(year)
           when LocalDate
-            Period.of_days(day_of_year - other.day_of_year)
+            Period.between(other, self)
           when Duration
             minus_days(other.to_days)
           when Numeric

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

@@ -7,6 +7,8 @@ module OpenHAB
     module Java
       java_import java.time.LocalTime
 
+      #
+      # Extensions to {java.time.LocalTime}
       #
       # @example
       #   break_time = LocalTime::NOON
@@ -36,15 +38,23 @@ module OpenHAB
         include Between
         # @!parse include Time
 
-        # @!visibility private
         class << self
+          # @!attribute [r] now
+          #   @return [LocalTime]
+
+          # @!visibility private
+          alias_method :raw_parse, :parse
+
           #
-          # Parses strings in the form "h[:mm[:ss]] [am/pm]"
+          # Parses strings in the form "h[:mm[:ss]] [am/pm]" when no formatter is given.
           #
           # @param [String] string
+          # @param [java.time.format.DateTimeFormatter] formatter The formatter to use
           # @return [LocalTime]
           #
-          def parse(string)
+          def parse(string, formatter = nil)
+            return raw_parse(string, formatter) if formatter
+
             format = /(am|pm)$/i.match?(string) ? "h[:mm[:ss][.S]][ ]a" : "H[:mm[:ss][.S]]"
             java_send(:parse, [java.lang.CharSequence, java.time.format.DateTimeFormatter],
                       string, java.time.format.DateTimeFormatterBuilder.new

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

@@ -7,7 +7,7 @@ module OpenHAB
     module Java
       Month = java.time.Month
 
-      # Extensions to Month
+      # Extensions to {java.time.Month}
       class Month
         include Between
         # @!parse include Time

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

@@ -7,7 +7,7 @@ module OpenHAB
     module Java
       java_import java.time.MonthDay
 
-      # Extensions to MonthDay
+      # Extensions to {java.time.MonthDay}
       class MonthDay
         include Between
         include Ephemeris
@@ -39,12 +39,22 @@ module OpenHAB
 
         # @return [MonthDay]
         def +(other)
-          (LocalDate.of(1900, month, day_of_month) + other).to_month_day
+          case other
+          when java.time.temporal.TemporalAmount, Numeric
+            (LocalDate.of(1900, month, day_of_month) + other).to_month_day
+          else
+            (to_local_date(other.to_local_date) + other).to_month_day
+          end
         end
 
         # @return [MonthDay, Period]
         def -(other)
-          d = (LocalDate.of(1900, month, day_of_month) - other)
+          d = case other
+              when java.time.temporal.TemporalAmount, Numeric
+                LocalDate.of(1900, month, day_of_month) - other
+              else
+                to_local_date(other.to_local_date) - other
+              end
           return d if d.is_a?(java.time.Period)
 
           d.to_month_day

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

@@ -5,7 +5,7 @@ module OpenHAB
     module Java
       java_import java.time.Period
 
-      # Extensions to Period
+      # Extensions to {java.time.Period}
       class Period
         # @!parse include TemporalAmount
 

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

@@ -5,7 +5,7 @@ module OpenHAB
     module Java
       java_import java.time.temporal.TemporalAmount
 
-      # Extensions to TemporalAmount
+      # Extensions to {java.time.temporal.TemporalAmount}
       module TemporalAmount
         # Subtract `self` to {ZonedDateTime.now}
         # @return [ZonedDateTime]

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

@@ -50,7 +50,11 @@ module OpenHAB
         # Convert `other` to this class, if possible
         # @return [Array, nil]
         def coerce(other)
-          [other.send(self.class.coercion_method), self] if other.respond_to?(self.class.coercion_method)
+          coercion_method = self.class.coercion_method
+          return unless other.respond_to?(coercion_method)
+          return [other.send(coercion_method), self] if other.method(coercion_method).arity.zero?
+
+          [other.send(coercion_method, self), self]
         end
       end
     end

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

@@ -7,18 +7,31 @@ module OpenHAB
     module Java
       ZonedDateTime = java.time.ZonedDateTime
 
-      # Extensions to ZonedDateTime
+      # Extensions to {java.time.ZonedDateTime}
       class ZonedDateTime
         include Time
         include Between
 
         class << self # rubocop:disable Lint/EmptyClass
+          # @!scope class
+
           # @!attribute [r] now
           #   @return [ZonedDateTime]
+
+          # @!method parse(text, formatter = nil)
+          #   Parses a string into a ZonedDateTime object.
+          #
+          #   @param [String] text The text to parse.
+          #   @param [java.time.format.DateTimeFormatter] formatter The formatter to use.
+          #   @return [ZonedDateTime]
         end
 
+        # @!scope instance
+
         # @return [LocalTime]
-        alias_method :to_local_time, :toLocalTime
+        def to_local_time(_context = nil)
+          toLocalTime
+        end
 
         # @return [Month]
         alias_method :to_month, :month

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

@@ -85,9 +85,9 @@ class Date
   #
   def coerce(other)
     return nil unless other.respond_to?(:to_date)
-    return [other.to_date(self), self] if other.method(:to_date).arity == 1
+    return [other.to_date, self] if other.method(:to_date).arity.zero?
 
-    [other.to_date, self]
+    [other.to_date(self), self]
   end
 
   remove_method :inspect

data/lib/openhab/core_ext/ruby/{class.rb → module.rb}

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
 
-# Extensions to Class
-class Class
+# Extensions to Module
+class Module
   #
-  # Returns the name of the class, without any containing module or package.
+  # Returns the name of the class or module, without any containing module or package.
   #
   # @return [String, nil]
   #

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

@@ -151,7 +151,12 @@ module OpenHAB
         # @return [QuantityType] `self` as a {QuantityType} of the supplied Unit
         #
         def |(unit) # rubocop:disable Naming/BinaryOperatorParameterName
-          unit = org.openhab.core.types.util.UnitUtils.parse_unit(unit.to_str) if unit.respond_to?(:to_str)
+          if unit.respond_to?(:to_str)
+            parsed_unit = org.openhab.core.types.util.UnitUtils.parse_unit(unit.to_str)
+            raise ArgumentError, "Unknown unit #{unit}" unless parsed_unit
+
+            unit = parsed_unit
+          end
 
           return super unless unit.is_a?(javax.measure.Unit)
 

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

@@ -187,6 +187,30 @@ module OpenHAB
           def item_factory
             @item_factory ||= org.openhab.core.library.CoreItemFactory.new
           end
+
+          #
+          # Convert the given array to an array of strings.
+          # Convert Semantics classes to their simple name.
+          #
+          # @param [String,Symbol,Semantics::Tag] tags A list of strings, symbols, or Semantics classes
+          # @return [Array] An array of strings
+          #
+          # @example
+          #   tags = normalize_tags("tag1", Semantics::LivingRoom)
+          #
+          # @!visibility private
+          def normalize_tags(*tags)
+            semantics = proc { |tag| tag.respond_to?(:java_class) && tag < Semantics::Tag }
+
+            tags.compact.map do |tag|
+              case tag
+              when String then tag
+              when Symbol then tag.to_s
+              when semantics then tag.java_class.simple_name
+              else raise ArgumentError, "`#{tag}` must be a subclass of Semantics::Tag, a `Symbol`, or a `String`."
+              end
+            end
+          end
         end
 
         # @param dimension [Symbol, nil] The unit dimension for a {NumberItem} (see {ItemBuilder#dimension})
@@ -294,18 +318,7 @@ module OpenHAB
         # @return [void]
         #
         def tag(*tags)
-          unless tags.all? do |tag|
-                   tag.is_a?(String) ||
-                   tag.is_a?(Symbol) ||
-                   (tag.is_a?(Module) && tag < Semantics::Tag)
-                 end
-            raise ArgumentError, "`tag` must be a subclass of Semantics::Tag, or a `String``."
-          end
-
-          tags.each do |tag|
-            tag = tag.name.split("::").last if tag.is_a?(Module) && tag < Semantics::Tag
-            @tags << tag.to_s
-          end
+          @tags += self.class.normalize_tags(*tags)
         end
 
         #

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

@@ -38,23 +38,25 @@ module OpenHAB
             # def command(state)
             #   return super(state) unless Thread.current[:openhab_ensure_states]
             #
+            #   formatted_state = format_command(state)
             #   logger.trace do
-            #     "#{name} ensure #{state}, format_command: #{format_command(state)}, current state: #{self.state}"
+            #     "#{name} ensure #{state}, format_command: #{formatted_state}, current state: #{raw_state}"
             #   end
-            #   return if self.state == format_command(state)
+            #   return if raw_state == formatted_state
             #
-            #   super(state)
+            #   super(formatted_state)
             # end
             class_eval <<~RUBY, __FILE__, __LINE__ + 1 # rubocop:disable Style/DocumentDynamicEvalDefinition
               def #{ensured_method}(state)
                 return super(state) unless Thread.current[:openhab_ensure_states]
 
+                formatted_state = format_#{ensured_method}(state)
                 logger.trace do
-                  "\#{name} ensure \#{state}, format_#{ensured_method}: \#{format_#{ensured_method}(state)}, current state: \#{self.state}"
+                  "\#{name} ensure \#{state}, format_#{ensured_method}: \#{formatted_state}, current state: \#{raw_state}"
                 end
-                return if self.state == format_#{ensured_method}(state)
+                return if raw_state.as(formatted_state.class) == formatted_state
 
-                super(state)
+                super(formatted_state)
               end
             RUBY
           end

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

@@ -35,7 +35,8 @@ module OpenHAB
           super()
           set_name(config.name)
           set_description(config.description)
-          set_tags(to_string_set(config.tags))
+          tags = DSL::Items::ItemBuilder.normalize_tags(*config.tags)
+          set_tags(tags.to_set)
           set_triggers(config.triggers)
           self.uid = config.uid
           @run_context = config.caller
@@ -297,28 +298,6 @@ module OpenHAB
           @run_context.instance_exec(&task.block)
         end
 
-        #
-        # Convert the given array to a set of strings.
-        # Convert Semantics classes to their simple name
-        #
-        # @example
-        #   to_string_set("tag1", Semantics::LivingRoom)
-        #
-        # @param tags [Array] An array of strings or Semantics classes
-        #
-        # @return [Set] A set of strings
-        #
-        def to_string_set(*tags)
-          tags = tags.flatten.map do |tag|
-            if tag.respond_to?(:java_class) && tag < org.openhab.core.semantics.Tag
-              tag.java_class.simple_name
-            else
-              tag.to_s
-            end
-          end
-          Set.new(tags)
-        end
-
         #
         # Create a new hash in which all elements are converted to strings
         #

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

@@ -358,7 +358,7 @@ module OpenHAB
         #
         # Set the rule's tags.
         #
-        # @param [String, Class, Array<String, Class>] tags
+        # @param [String, Symbol, Semantics::Tag] tags A list of tags to assign to the rule.
         # @return [void]
         #
         # @example
@@ -1101,7 +1101,10 @@ module OpenHAB
         #   :saturday,
         #   :sunday] value
         #   When to execute rule.
-        # @param [LocalTime, String, nil] at What time of day to execute rule
+        # @param [LocalTime, String, Core::Items::DateTimeItem, nil] at What time of day to execute rule
+        #   If `value` is `:day`, `at` can be a {Core::Items::DateTimeItem DateTimeItem}, and
+        #   the trigger will run every day at the (time only portion of) current state of the
+        #   item. If the item is {NULL} or {UNDEF}, the trigger will not run.
         # @param [Object] attach Object to be attached to the trigger
         # @return [void]
         #
@@ -1157,11 +1160,23 @@ module OpenHAB
         #     run { logger.info "Happy Valentine's Day!" }
         #   end
         #
+        # @example
+        #   rule "Every day at sunset" do
+        #     every :day, at: Sunset_Time
+        #     run { logger.info "It's getting dark" }
+        #   end
+        #
         def every(value, at: nil, attach: nil)
           return every(java.time.MonthDay.parse(value), at: at, attach: attach) if value.is_a?(String)
 
           @ruby_triggers << [:every, value, { at: at }]
 
+          if value == :day && at.is_a?(Item)
+            raise ArgumentError, "Attachments are not supported with dynamic datetime triggers" unless attach.nil?
+
+            return trigger("timer.DateTimeTrigger", itemName: at.name, timeOnly: true)
+          end
+
           cron_expression = case value
                             when Symbol then Cron.from_symbol(value, at)
                             when Duration then Cron.from_duration(value, at)
@@ -1502,6 +1517,36 @@ module OpenHAB
           trigger("core.GenericEventTrigger", eventTopic: topic, eventSource: source, eventTypes: types, attach: attach)
         end
 
+        #
+        # Creates a trigger based on the time stored in a {DateTimeItem}
+        #
+        # The trigger will dynamically update any time the state of the item
+        # changes. If the item is {NULL} or {UNDEF}, the trigger will not run.
+        #
+        # @param [Item, String, Symbol] item The item (or it's name)
+        # @return [void]
+        #
+        # @example
+        #   rule "say hello when the kids get home from school" do
+        #     at HomeFromSchool_Time
+        #     run do
+        #       KitchenEcho_TTS << "hi kids! how was school?"
+        #     end
+        #   end
+        #
+        #   rule "set home from school time" do
+        #     on_load
+        #     every :day, at: "5:00am" do
+        #     run do
+        #       HomeFromSchool_Time.ensure.update(school_day? ? LocalTime.parse("3:30pm") : NULL)
+        #     end
+        #   end
+        #
+        def at(item)
+          item = item.name if item.is_a?(Item)
+          trigger("timer.DateTimeTrigger", itemName: item.to_s)
+        end
+
         #
         # Create a generic trigger given the trigger type uid and a configuration hash
         #