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

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 38b109c413cbb8b06c2c43e57ad12e6278139b1cf56d887289ada297c8991272
-  data.tar.gz: 24e6235ce553d4e2ec9447c94407054b9c1c075c6a190a3ce5ed5ebb2421753c
+  metadata.gz: 8ef6b7b058463c4bbcbc500b23baf44e1ef8f3872c39f88f3819875523b9d350
+  data.tar.gz: f2c5511e9c61eb79a1464161d35ba239570e45172be44415784994688a789c67
 SHA512:
-  metadata.gz: a3e0f9f2f58d906ff72f5923817a2b5651a96f4710bbd29ad6ecffc3991722db5f8b1702de90e05ef1854ffe49c3d4214a699f271aaf0ac26a2dd03ad20c71f5
-  data.tar.gz: a51e80b23b82e7c38db1ac8d263b0a2776a70ad7fe9f401b1ae035f26a06d3660534e4c64c4d1c88a06fb9ee47ef64422b02bdfd26446e8edb148461c1403eca
+  metadata.gz: 7b4aca0a4cb592c7bcb84c4c50772d359cfc704f4bccb31e3aa58a1e76be0e15de9276c0184bcd696aed1c05cb7361e0f4d74f892eb9347f0a43f54ac596ecdb
+  data.tar.gz: 1053d9bd85f8013bcfa37242f1354e333587884179f8600c4f48ad19c5d1aa8cfdbb7795a32b37147d83d1b11334cb993663e761c4a0c2cf9574b5ec1355586e

data/lib/openhab/core/actions/transformation.rb

@@ -7,7 +7,7 @@ module OpenHAB
       class Transformation
         class << self
           # @!visibility private
-          alias_method :transform_raw, :transform if instance_methods.include?(:say)
+          alias_method :raw_transform, :transform if instance_methods.include?(:transform)
 
           #
           # Applies a transformation of a given type with some function to a value.
@@ -20,10 +20,10 @@ module OpenHAB
           # @return [String] the transformed value, or the original value if an error occurred
           #
           # @example Run a transformation
-          #   Transformation.transform(:map, "myfan.map", 0)
+          #   transform(:map, "myfan.map", 0)
           #
           def transform(type, function, value)
-            transform_raw(type.to_s.upcase, function.to_s, value.to_s)
+            raw_transform(type.to_s.upcase, function.to_s, value.to_s)
           end
         end
       end

data/lib/openhab/core/actions.rb

@@ -43,7 +43,7 @@ module OpenHAB
       end
 
       # Import common actions
-      %w[Exec HTTP Ping].each do |action|
+      %w[Exec HTTP Ping Transformation].each do |action|
         klass = (java_import "org.openhab.core.model.script.actions.#{action}").first
         Object.const_set(action, klass)
       end

data/lib/openhab/core/events/item_command_event.rb

@@ -7,71 +7,71 @@ module OpenHAB
     module Events
       java_import org.openhab.core.items.events.ItemCommandEvent
 
-      # Adds methods to core openHAB ItemCommandEvent to make it more natural in Ruby
+      # {AbstractEvent} sent when an item receives a command.
       class ItemCommandEvent < ItemEvent
         # @!attribute [r] command
         # @return [Command] The command sent to the item.
         alias_method :command, :item_command
 
         # @!method refresh?
-        #   Check if `self == REFRESH`
-        #   @return [true,false]
+        #   Check if {#command} is {REFRESH}
+        #   @return [true, false]
 
         # @!method on?
-        #   Check if `self == ON`
-        #   @return [true,false]
+        #   Check if {#command} is (implicitly convertible to) {ON}
+        #   @return [true, false]
 
         # @!method off?
-        #   Check if `self == OFF`
-        #   @return [true,false]
+        #   Check if {#command} is (implicitly convertible to) {OFF}
+        #   @return [true, false]
 
         # @!method up?
-        #   Check if `self == UP`
-        #   @return [true,false]
+        #   Check if {#command} is (implicitly convertible to) {UP}
+        #   @return [true, false]
 
         # @!method down?
-        #   Check if `self == DOWN`
-        #   @return [true,false]
+        #   Check if {#command} is (implicitly convertible to) {DOWN}
+        #   @return [true, false]
 
         # @!method stop?
-        #   Check if `self == STOP`
-        #   @return [true,false]
+        #   Check if {#command} is {STOP}
+        #   @return [true, false]
 
         # @!method move?
-        #   Check if `self == MOVE`
-        #   @return [true,false]
+        #   Check if {#command} is {MOVE}
+        #   @return [true, false]
 
         # @!method increase?
-        #   Check if `self == INCREASE`
-        #   @return [true,false]
+        #   Check if {#command} is {INCREASE}
+        #   @return [true, false]
 
         # @!method decrease?
-        #   Check if `self == DECREASE`
-        #   @return [true,false]
+        #   Check if {#command} is {DECREASE}
+        #   @return [true, false]
 
         # @!method play?
-        #   Check if `self == PLAY`
-        #   @return [true,false]
+        #   Check if {#command} is {PLAY}
+        #   @return [true, false]
 
         # @!method pause?
-        #   Check if `self == PAUSE`
-        #   @return [true,false]
+        #   Check if {#command} is {PAUSE}
+        #   @return [true, false]
 
         # @!method rewind?
-        #   Check if `self == REWIND`
-        #   @return [true,false]
+        #   Check if {#command} is {REWIND}
+        #   @return [true, false]
 
         # @!method fast_forward?
-        #   Check if `self == FASTFORWARD`
-        #   @return [true,false]
+        #   Check if {#command} is {FASTFORWARD}
+        #   @return [true, false]
 
         # @!method next?
-        #   Check if `self == NEXT`
-        #   @return [true,false]
+        #   Check if {#command} is {NEXT}
+        #   @return [true, false]
 
         # @!method previous?
-        #   Check if `self == PREVIOUS`
-        #   @return [true,false]
+        #   Check if {#command} is {PREVIOUS}
+        #   @return [true, false]
       end
     end
   end

data/lib/openhab/core/events/item_state_changed_event.rb

@@ -8,32 +8,55 @@ module OpenHAB
       java_import org.openhab.core.items.events.ItemStateChangedEvent
 
       #
-      # Adds methods to core openHAB ItemStateChangedEvent to make it more natural in Ruby
+      # {AbstractEvent} sent when an item's state has changed.
       #
       class ItemStateChangedEvent < ItemEvent
         include ItemState
 
-        #
-        # Check if state was == {UNDEF}
-        #
-        # @return [true,false] True if the state is {UNDEF}, false otherwise
-        #
-        def was_undef?
-          old_item_state == UNDEF
-        end
+        # @!method was_undef?
+        #   Check if {#was} is {UNDEF}
+        #   @return [true, false]
 
-        #
-        # Check if state was == {NULL}
-        #
-        # @return [true,false] True if the state is {NULL}, false otherwise
-        def was_null?
-          old_item_state == NULL
-        end
+        # @!method was_null?
+        #   Check if {#was} is {NULL}
+        #   @return [true, false]
+
+        # @!method was_on?
+        #   Check if {#was} is (implicitly convertible to) {ON}
+        #   @return [true, false]
+
+        # @!method was_off?
+        #   Check if {#was} is (implicitly convertible to) {OFF}
+        #   @return [true, false]
+
+        # @!method was_up?
+        #   Check if {#was} is (implicitly convertible to) {UP}
+        #   @return [true, false]
+
+        # @!method was_down?
+        #   Check if {#was} is (implicitly convertible to) {DOWN}
+        #   @return [true, false]
+
+        # @!method was_open?
+        #   Check if {#was} is (implicitly convertible to) {OPEN}
+        #   @return [true, false]
+
+        # @!method was_closed?
+        #   Check if {#was} is (implicitly convertible to) {CLOSED}
+        #   @return [true, false]
+
+        # @!method was_playing?
+        #   Check if {#was} is {PLAY}
+        #   @return [true, false]
+
+        # @!method was_paused?
+        #   Check if {#was} is {PAUSE}
+        #   @return [true, false]
 
         #
         # Check if state was defined (not {UNDEF} or {NULL})
         #
-        # @return [true,false] True if state is not {UNDEF} or {NULL}
+        # @return [true,false]
         #
         def was?
           !old_item_state.is_a?(UnDefType)
@@ -41,7 +64,7 @@ module OpenHAB
 
         #
         # @!attribute [r] was
-        # @return [State, nil] The state of the item if it was not {UNDEF} or {NULL}, `nil` otherwise.
+        # @return [State, nil] the prior state of the item if it was not {UNDEF} or {NULL}, `nil` otherwise.
         #
         def was
           old_item_state if was?

data/lib/openhab/core/events/item_state_event.rb

@@ -5,29 +5,57 @@ module OpenHAB
     module Events
       java_import org.openhab.core.items.events.ItemStateEvent
 
+      #
       # Helpers common to {ItemStateEvent} and {ItemStateChangedEvent}.
+      #
+      # Methods that refer to implicit conversion mean that for example
+      # a PercentType of 100% will be `true` for {#on?}, etc.
+      #
       module ItemState
-        #
-        # Check if the state == {UNDEF}
-        #
-        # @return [true,false] True if the state is {UNDEF}, false otherwise
-        #
-        def undef?
-          item_state == UNDEF
-        end
+        # @!method undef?
+        #   Check if {#state} is {UNDEF}
+        #   @return [true, false]
 
-        #
-        # Check if the state == {NULL}
-        #
-        # @return [true,false] True if the state is {NULL}, false otherwise
-        def null?
-          item_state == NULL
-        end
+        # @!method null?
+        #   Check if {#state} is {NULL}
+        #   @return [true, false]
+
+        # @!method on?
+        #   Check if {#state} is (implicitly convertible to) {ON}
+        #   @return [true, false]
+
+        # @!method off?
+        #   Check if {#state} is (implicitly convertible to) {OFF}
+        #   @return [true, false]
+
+        # @!method up?
+        #   Check if {#state} is (implicitly convertible to) {UP}
+        #   @return [true, false]
+
+        # @!method down?
+        #   Check if {#state} is (implicitly convertible to) {DOWN}
+        #   @return [true, false]
+
+        # @!method open?
+        #   Check if {#state} is (implicitly convertible to) {OPEN}
+        #   @return [true, false]
+
+        # @!method closed?
+        #   Check if {#state} is (implicitly convertible to) {CLOSED}
+        #   @return [true, false]
+
+        # @!method playing?
+        #   Check if {#state} is {PLAY}
+        #   @return [true, false]
+
+        # @!method paused?
+        #   Check if {#state} is {PAUSE}
+        #   @return [true, false]
 
         #
-        # Check if the state is defined (not {UNDEF} or {NULL})
+        # Check if {#state} is defined (not {UNDEF} or {NULL})
         #
-        # @return [true,false] True if state is not {UNDEF} or {NULL}
+        # @return [true, false]
         #
         def state?
           !item_state.is_a?(UnDefType)
@@ -35,7 +63,7 @@ module OpenHAB
 
         #
         # @!attribute [r] state
-        # @return [State, nil] The state of the item if it is not {UNDEF} or {NULL}, `nil` otherwise.
+        # @return [State, nil] the state of the item if it is not {UNDEF} or {NULL}, `nil` otherwise.
         #
         def state
           item_state if state?

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

@@ -71,6 +71,34 @@ module OpenHAB
           !raw_state.is_a?(Types::UnDefType)
         end
 
+        # @!attribute [r] formatted_state
+        #
+        # Format the item's state according to its state description
+        #
+        # This may include running a transformation.
+        #
+        # @return [String]
+        #
+        # @example
+        #   logger.info(Exterior_WindDirection.formatted_state) # => "NE (36°)"
+        #
+        def formatted_state
+          # use to_string, not to_s, to get the original openHAB toString(), instead of any overrides
+          # the JRuby library has defined
+          raw_state_string = raw_state.to_string
+
+          return raw_state_string unless (pattern = state_description&.pattern)
+
+          transformed_state_string = org.openhab.core.transform.TransformationHelper.transform(OSGi.bundle_context,
+                                                                                               pattern,
+                                                                                               raw_state_string)
+          return state.format(pattern) if transformed_state_string.nil? || transformed_state_string == raw_state_string
+
+          transformed_state_string
+        rescue org.openhab.core.transform.TransformationException
+          raw_state_string
+        end
+
         #
         # @!attribute [r] state
         # @return [State, nil]
@@ -153,7 +181,7 @@ module OpenHAB
           return state if state.is_a?(Types::State)
 
           state = state.to_s
-          org.openhab.core.types.TypeParser.parse_state(getAcceptedDataTypes, state) || state
+          org.openhab.core.types.TypeParser.parse_state(getAcceptedDataTypes, state) || StringType.new(state)
         end
 
         # formats a {Types::Type} to send to the event bus

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

@@ -44,12 +44,49 @@ module OpenHAB
         #
         # Returns all groups that this item is part of
         #
-        # @return [Array<Group>] All groups that this item is part of
+        # @return [Array<GroupItem>] All groups that this item is part of
         #
         def groups
           group_names.map { |name| EntityLookup.lookup_item(name) }.compact
         end
 
+        #
+        # Checks if this item is a member of at least one of the given groups.
+        #
+        # @param groups [String, GroupItem] the group to check membership in
+        # @return [true, false]
+        #
+        # @example
+        #   event.item.member_of?(gFullOn)
+        #
+        def member_of?(*groups)
+          groups = groups.map! do |group|
+            group.is_a?(GroupItem) ? group.name : group
+          end
+          !(group_names & groups).empty?
+        end
+
+        #
+        # @!attribute [r] all_groups
+        #
+        # Returns all groups that this item is a part of, as well as those groups' groups, recursively
+        #
+        # @return [Array<GroupItem>]
+        #
+        def all_groups
+          result = []
+          new_groups = Set.new(groups)
+
+          until new_groups.empty?
+            result.concat(new_groups.to_a)
+            new_groups.replace(new_groups.flat_map(&:groups))
+            # remove any groups we already have in the result to avoid loops
+            new_groups.subtract(result)
+          end
+
+          result
+        end
+
         # rubocop:disable Layout/LineLength
 
         # @!attribute [r] metadata
@@ -172,6 +209,22 @@ module OpenHAB
         end
         # rubocop:enable Layout/LineLength
 
+        #
+        # Checks if this item has at least one of the given tags.
+        #
+        # @param tags [String, Module] the tag(s) to check
+        # @return [true, false]
+        #
+        # @example
+        #   event.item.tagged?("Setpoint")
+        #
+        def tagged?(*tags)
+          tags = tags.map! do |tag|
+            tag.is_a?(Module) ? tag.simple_name : tag
+          end
+          !(self.tags.to_a & tags).empty?
+        end
+
         # Return the item's thing if this item is linked with a thing. If an item is linked to more than one thing,
         # this method only returns the first thing.
         #

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

@@ -34,6 +34,10 @@ module OpenHAB
           item.members.each { |member| remove(member.name, true) } if recursive && item.is_a?(GroupItem)
           item
         end
+
+        def initialize
+          super(unload_priority: 50)
+        end
       end
     end
   end

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

@@ -40,33 +40,56 @@ module Enumerable
   #
 
   # Returns a new array of items that have at least one of the given tags
+  #
+  # @param tags [String, Module]
   # @return [Array<Item>]
   def tagged(*tags)
-    reject { |i| (tags & i.tags.to_a).empty? }
+    select { |i| i.tagged?(*tags) }
   end
 
   # Returns a new array of items that do not have any of the given tags
+  # @param tags [String, Module]
   # @return [Array<Item>]
   def not_tagged(*tags)
-    select { |i| (tags & i.tags.to_a).empty? }
+    reject { |i| i.tagged?(*tags) }
   end
 
   # Returns a new array of items that are a member of at least one of the given groups
+  # @param groups [String, GroupItem]
   # @return [Array<Item>]
   def member_of(*groups)
-    reject { |i| (groups.map(&:name) & i.group_names).empty? }
+    select { |i| i.member_of?(*groups) }
   end
 
   # Returns a new array of items that are not a member of any of the given groups
+  # @param groups [String, GroupItem]
   # @return [Array<Item>]
   def not_member_of(*groups)
-    select { |i| (groups.map(&:name) & i.group_names).empty? }
+    reject { |i| i.member_of?(*groups) }
   end
 
-  # Returns the group members the elements
+  # Returns the group members of all group elements
   # @return [Array<Item>]
   def members
-    grep(OpenHAB::Core::Items::GroupItem).flat_map(&:members)
+    grep(OpenHAB::Core::Items::GroupItem).flat_map(&:members).uniq
+  end
+
+  # Returns all non-group members of all group elements, recursively
+  # @return [Array<Item>]
+  def all_members
+    grep(OpenHAB::Core::Items::GroupItem).flat_map(&:all_members).uniq
+  end
+
+  # Returns the groups of all elements
+  # @return [Array<GroupItem>]
+  def groups
+    flat_map(&:groups).uniq
+  end
+
+  # Returns all groups all elements are a part of, recursively
+  # @return [Array<GroupItem>]
+  def all_groups
+    flat_map(&:all_groups).uniq
   end
 
   # @!group Items State and Command Methods

data/lib/openhab/core/items.rb

@@ -46,9 +46,9 @@ module OpenHAB
 
             logger.trace("Defining #{klass}##{state_predicate} for #{state}")
             klass.class_eval <<~RUBY, __FILE__, __LINE__ + 1
-              def #{state_predicate}   # def on?
-                raw_state == #{state}  #   raw_state == ON
-              end                      # end
+              def #{state_predicate}                                                  # def on?
+                raw_state.as(#{state.class.java_class.simple_name}).equal?(#{state})  #   raw_state.as(OnOffType) == ON
+              end                                                                     # end
             RUBY
           end
         end
@@ -74,18 +74,11 @@ module OpenHAB
               end                   # end
             RUBY
 
-            # Override the inherited methods from Enumerable and send it to the base_item
-            GroupItem.class_eval <<~RUBY, __FILE__, __LINE__ + 1
-              def #{command}                 # def on
-                method_missing(:#{command})  #   method_missing(:on)
-              end                            # end
-            RUBY
-
             logger.trace("Defining ItemCommandEvent##{command}? for #{value}")
             Events::ItemCommandEvent.class_eval <<~RUBY, __FILE__, __LINE__ + 1
-              def #{command}?        # def refresh?
-                command == #{value}  #   command == REFRESH
-              end                    # end
+              def #{command}?                                                       # def refresh?
+                command.as(#{value.class.java_class.simple_name}).equal?(#{value})  #   command.as(RefreshType).equal?(REFRESH)
+              end                                                                   # end
             RUBY
           end
         end

data/lib/openhab/core/provider.rb

@@ -219,11 +219,11 @@ module OpenHAB
 
       private
 
-      def initialize(script_unloaded_before: nil)
+      def initialize(unload_priority: nil)
         super()
         @elements = java.util.concurrent.ConcurrentHashMap.new
         self.class.registry.add_provider(self)
-        ScriptHandling.script_unloaded(before: script_unloaded_before) { unregister }
+        ScriptHandling.script_unloaded(priority: unload_priority) { unregister }
       end
     end
   end

data/lib/openhab/core/rules/provider.rb

@@ -19,21 +19,6 @@ module OpenHAB
             $rules
           end
         end
-
-        def initialize
-          super(script_unloaded_before: lambda do |callbacks|
-            callbacks.index do |cb|
-              case cb.binding.receiver
-              when Items::Provider,
-                Things::Provider,
-                DSL::TimerManager
-                true
-              else
-                false
-              end
-            end
-          end)
-        end
       end
     end
   end

data/lib/openhab/core/script_handling.rb

@@ -32,8 +32,6 @@ module OpenHAB
         ScriptHandlingCallbacks.script_loaded_hooks << block
       end
 
-      #
-      # @!method script_unloaded(&block)
       #
       # Add a block of code to be executed when the script is unloaded.
       #
@@ -42,6 +40,10 @@ module OpenHAB
       # Multiple hooks can be added by calling {#script_unloaded} multiple times.
       # They can be used to perform final cleanup.
       #
+      # @param [Integer, nil] priority The order at which the the given hook will be executed.
+      #   The higher the number, the lower the priority. Higher priority hooks will be executed
+      #   first, before the lower priority hooks. When nil, the default priority of zero will
+      #   be used.
       # @return [void]
       #
       # @example
@@ -49,10 +51,8 @@ module OpenHAB
       #     logger.info 'Hi, this script has been unloaded'
       #   end
       #
-      def script_unloaded(before: nil, &block)
-        # `before` is as yet undocumented, because I'm not set on its interface
-        index = before.call(ScriptHandlingCallbacks.script_unloaded_hooks) if before
-        ScriptHandlingCallbacks.script_unloaded_hooks.insert(index || -1, block)
+      def script_unloaded(priority: nil, &block)
+        ScriptHandlingCallbacks.script_unloaded_hooks[priority || 0] << block
       end
     end
 
@@ -82,7 +82,7 @@ module OpenHAB
         #
         # @!visibility private
         def script_unloaded_hooks
-          @script_unloaded_hooks ||= []
+          @script_unloaded_hooks ||= Hash.new { |hash, key| hash[key] = [] }
         end
       end
       self.script_loaded = false
@@ -92,7 +92,7 @@ module OpenHAB
       #
       def scriptUnloaded # rubocop:disable Naming/MethodName method name dictated by openHAB
         logger.trace("Script unloaded")
-        ScriptHandlingCallbacks.script_unloaded_hooks.each do |hook|
+        ScriptHandlingCallbacks.script_unloaded_hooks.sort_by(&:first).flat_map(&:last).each do |hook|
           hook.call
         rescue => e
           logger.error("Failed to call script_unloaded hook #{hook}: #{e}")

data/lib/openhab/core/things/provider.rb

@@ -19,6 +19,10 @@ module OpenHAB
             $things
           end
         end
+
+        def initialize
+          super(unload_priority: 60)
+        end
       end
     end
   end

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_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/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/terse.rb

@@ -20,27 +20,29 @@ module OpenHAB
         class << self
           # @!visibility private
           # @!macro def_terse_rule
-          #   @!method $1(*args, name :nil, id: nil, **kwargs, &block)
+          #   @!method $1(*args, name :nil, id: nil, on_load: false, **kwargs, &block)
           #   Create a new rule with a $1 trigger.
           #   @param name [String] The name for the rule.
           #   @param id [String] The ID for the rule.
+          #   @param on_load [true, false] If the rule should _also_ trigger immediately when the script loads.
           #   @yield The execution block for the rule.
           #   @return [void]
           #   @see BuilderDSL#$1
           def def_terse_rule(trigger)
             class_eval(<<~RUBY, __FILE__, __LINE__ + 1)
-              def #{trigger}(*args, name: nil, id: nil, **kwargs, &block)     # def changed(*args, name: nil, id: nil, **kwargs, &block)
-                raise ArgumentError, "Block is required" unless block         #   raise ArgumentError, "Block is required" unless block
-                                                                              #
-                id ||= NameInference.infer_rule_id_from_block(block)          #   id ||= NameInference.infer_rule_id_from_block(block)
-                script = block.source rescue nil                              #   script = block.source rescue nil
-                caller_binding = block.binding                                #   caller_binding = block.binding
-                rule name, id: id, script: script, binding: caller_binding do #   rule name, id: id, script: script, binding: caller_binding do
-                  #{trigger}(*args, **kwargs)                                 #     changed(*args, **kwargs)
-                  run(&block)                                                 #     run(&block)
-                end                                                           #   end
-              end                                                             # end
-              module_function #{trigger.inspect}                              # module_function :changed
+              def #{trigger}(*args, name: nil, id: nil, on_load: false, **kwargs, &block)     # def changed(*args, name: nil, id: nil, on_load: false, **kwargs, &block)
+                raise ArgumentError, "Block is required" unless block                         #   raise ArgumentError, "Block is required" unless block
+                                                                                              #
+                id ||= NameInference.infer_rule_id_from_block(block)                          #   id ||= NameInference.infer_rule_id_from_block(block)
+                script = block.source rescue nil                                              #   script = block.source rescue nil
+                caller_binding = block.binding                                                #   caller_binding = block.binding
+                rule name, id: id, script: script, binding: caller_binding do                 #   rule name, id: id, script: script, binding: caller_binding do
+                  self.on_load if on_load                                                     #     self.on_load if on_load
+                  #{trigger}(*args, **kwargs)                                                 #     changed(*args, **kwargs)
+                  run(&block)                                                                 #     run(&block)
+                end                                                                           #   end
+              end                                                                             # end
+              module_function #{trigger.inspect}                                              # module_function :changed
             RUBY
           end
         end

data/lib/openhab/dsl/timer_manager.rb

@@ -11,7 +11,7 @@ module OpenHAB
     class TimerManager
       include Singleton
 
-      Core::ScriptHandling.script_unloaded { instance.cancel_all }
+      Core::ScriptHandling.script_unloaded(priority: 40) { instance.cancel_all }
 
       # @!visibility private
       def initialize

data/lib/openhab/dsl/version.rb

@@ -4,6 +4,6 @@ module OpenHAB
   module DSL
     # Version of openHAB helper libraries
     # @return [String]
-    VERSION = "5.0.0.rc12"
+    VERSION = "5.0.0.rc.13"
   end
 end

data/lib/openhab/dsl.rb

@@ -30,6 +30,12 @@ module OpenHAB
     # include this before Core::Actions so that Core::Action's method_missing
     # takes priority
     include Core::EntityLookup
+    #
+    # @!parse
+    #   include Core::Actions
+    #   include Core::ScriptHandling
+    #   include Rules::Terse
+    #
     [Core::Actions, Core::ScriptHandling, Rules::Terse].each do |mod|
       # make these available both as regular and class methods
       include mod
@@ -473,6 +479,11 @@ module OpenHAB
       debounce(for: duration, id: id, &block)
     end
 
+    # (see Core::Actions::Transformation.transform)
+    def transform(type, function, value)
+      Transformation.transform(type, function, value)
+    end
+
     #
     # Limit how often the given block executes to the specified interval.
     #

data/lib/openhab/osgi.rb

@@ -52,10 +52,8 @@ module OpenHAB
         )
       end
 
-      private
-
       # @!attribute [r] bundle_context
-      # @return [org.osgi.framework.BundleContext] OSGi bundle context
+      # @return [org.osgi.framework.BundleContext] OSGi bundle context for ScriptExtension Class
       def bundle_context
         @bundle_context ||= bundle.bundle_context
       end

data/lib/openhab/rspec/helpers.rb

@@ -12,9 +12,6 @@ module OpenHAB
   # @example Corresponds to `transform/compass.script`
   #   OpenHAB::Transform.compass("30", param: "7")
   #
-  # @example Corresponds to `transform/ruby/compass.script`
-  #   OpenHAB::Transform::Ruby.compass("59 °")
-
   module Transform
     class << self
       # @!visibility private

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: openhab-jrubyscripting
 version: !ruby/object:Gem::Version
-  version: 5.0.0.rc12
+  version: 5.0.0.rc.13
 platform: ruby
 authors:
 - Cody Cutrer
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-01-26 00:00:00.000000000 Z
+date: 2023-02-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -94,6 +94,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.2'
+- !ruby/object:Gem::Dependency
+  name: gem-release
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.2'
 - !ruby/object:Gem::Dependency
   name: guard-rubocop
   requirement: !ruby/object:Gem::Requirement
@@ -453,9 +467,9 @@ files:
 - lib/openhab/core_ext/java/unit.rb
 - lib/openhab/core_ext/java/zoned_date_time.rb
 - lib/openhab/core_ext/ruby/array.rb
-- lib/openhab/core_ext/ruby/class.rb
 - lib/openhab/core_ext/ruby/date.rb
 - lib/openhab/core_ext/ruby/date_time.rb
+- lib/openhab/core_ext/ruby/module.rb
 - lib/openhab/core_ext/ruby/numeric.rb
 - lib/openhab/core_ext/ruby/range.rb
 - lib/openhab/core_ext/ruby/symbol.rb
@@ -537,14 +551,14 @@ files:
 - lib/openhab/yard/tags/constant_directive.rb
 - lib/openhab/yard/tags/group_directive.rb
 - lib/openhab/yard/tags/library.rb
-homepage: https://ccutrer.github.io/openhab-jrubyscripting/
+homepage: https://openhab.github.io/openhab-jruby/
 licenses:
 - EPL-2.0
 metadata:
-  homepage_uri: https://ccutrer.github.io/openhab-jrubyscripting/
-  source_code_uri: https://github.com/ccutrer/openhab-jrubyscripting
-  documentation_uri: https://ccutrer.github.io/openhab-jrubyscripting/
-  changelog_uri: https://ccutrer.github.io/openhab-jrubyscripting/file.CHANGELOG.html
+  homepage_uri: https://openhab.github.io/openhab-jruby/
+  source_code_uri: https://github.com/openhab/openhab-jruby
+  documentation_uri: https://openhab.github.io/openhab-jruby/
+  changelog_uri: https://openhab.github.io/openhab-jruby/file.CHANGELOG.html
   rubygems_mfa_required: 'true'
 post_install_message: 
 rdoc_options: []
@@ -561,7 +575,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: 1.3.1
 requirements: []
-rubygems_version: 3.3.7
+rubygems_version: 3.3.26
 signing_key: 
 specification_version: 4
 summary: JRuby Helper Libraries for openHAB Scripting