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

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

@@ -24,10 +24,6 @@ module OpenHAB
         #   The item's name.
         #   @return [String]
 
-        # @!attribute [r] label
-        #   The item's descriptive label.
-        #   @return [String, nil]
-
         # @!attribute [r] accepted_command_types
         #   @return [Array<Class>] An array of {Command}s that can be sent as commands to this item
 
@@ -35,7 +31,7 @@ module OpenHAB
         #   @return [Array<Class>] An array of {State}s that can be sent as commands to this item
 
         #
-        # The item's {#label} if one is defined, otherwise it's {#name}.
+        # The item's {GenericItem#label label} if one is defined, otherwise its {#name}.
         #
         # @return [String]
         #
@@ -46,14 +42,51 @@ module OpenHAB
         #
         # @!attribute [r] groups
         #
-        # Return all groups that this item is part of
+        # 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
@@ -81,7 +114,7 @@ module OpenHAB
         # @example Access namespace1's configuration
         #   Item1.metadata["namespace1"]["config1"]
         #
-        # @example Safely search for the specified value - no errors are raised, only nil returned if a key in the chain doesn"t exist
+        # @example Safely search for the specified value - no errors are raised, only nil returned if a key in the chain doesn't exist
         #   Item1.metadata.dig("namespace1", "config1") # => "foo"
         #   Item1.metadata.dig("namespace2", "config1") # => nil
         #
@@ -176,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.
         #
@@ -189,7 +238,7 @@ module OpenHAB
         #
         # @return [Array<Thing>] An array of things or an empty array
         def things
-          registry = OSGi.service("org.openhab.core.thing.link.ItemChannelLinkRegistry")
+          registry = Things::Links::Provider.registry
           channels = registry.get_bound_channels(name).to_a
           channels.map(&:thing_uid).uniq.map { |tuid| EntityLookup.lookup_thing(tuid) }.compact
         end
@@ -206,6 +255,11 @@ module OpenHAB
           "#{s}>"
         end
 
+        # @return [org.openhab.core.common.registry.Provider]
+        def provider
+          Provider.registry.provider_for(self)
+        end
+
         private
 
         # Allows sub-classes to append additional details to the type in an inspect string

data/lib/openhab/core/items/metadata/hash.rb

@@ -384,7 +384,7 @@ module OpenHAB
           alias_method :to_s, :inspect
 
           #
-          # @raise [RuntimeError] if the provider is not a
+          # @raise [FrozenError] if the provider is not a
           #   {org.openhab.core.common.registry.ManagedProvider ManagedProvider} that can be updated.
           # @return [org.openhab.core.common.registry.ManagedProvider]
           #

data/lib/openhab/core/items/metadata/namespace_hash.rb

@@ -218,8 +218,12 @@ module OpenHAB
             return @hash.each_key(&block) unless attached?
             return to_enum(:each_key) unless block
 
-            Provider.registry.all.each do |meta|
-              yield meta.uid.namespace if meta.uid.item_name == @item_name
+            if Provider.registry.respond_to?(:get_all_namespaces)
+              keys.each(&block)
+            else
+              Provider.registry.all.each do |meta|
+                yield meta.uid.namespace if meta.uid.item_name == @item_name
+              end
             end
             self
           end
@@ -313,6 +317,10 @@ module OpenHAB
 
           # @!visibility private
           def keys
+            if Provider.registry.respond_to?(:get_all_namespaces)
+              return Provider.registry.get_all_namespaces(@item_name).to_a
+            end
+
             each_key.to_a
           end
 

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

@@ -32,8 +32,8 @@ module OpenHAB
           # @return [void]
           #
           def remove_item_metadata(item_name)
-            @elements.delete_if do |k, v|
-              next unless k.item_name == item_name
+            @elements.delete_if do |_k, v|
+              next unless v.uid.item_name == item_name
 
               notify_listeners_about_removed_element(v)
               true

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

@@ -77,7 +77,6 @@ module OpenHAB
                               %i[changed_since?
                                  count_since
                                  count_state_changes_since
-                                 evolution_rate
                                  historic_state
                                  maximum_since
                                  minimum_since
@@ -183,11 +182,22 @@ module OpenHAB
         #   @return [true,false] True if the item's state changed between `start` and `finish`, False otherwise.
 
         # @!method evolution_rate(timestamp, service = nil)
-        #   Returns the evolution rate of the item's state since the given time
-        #   @param [#to_zoned_date_time] timestamp The point in time from which to search
-        #   @param [Symbol, String] service An optional persistence id instead of the default persistence service.
+        #   Returns the evolution rate of the item's state
         #   @return [DecimalType, QuantityType, nil] The evolution rate since `timestamp`,
         #     or nil if no previous state could be found.
+        #   @overload evolution_rate(timestamp, service = nil)
+        #     Returns the evolution rate of the item's state since the given time
+        #     @param [#to_zoned_date_time] timestamp The point in time from which to search
+        #     @param [Symbol, String] service An optional persistence id instead of the default persistence service.
+        #     @return [DecimalType, QuantityType, nil] The evolution rate since `timestamp`,
+        #       or nil if no previous state could be found.
+        #   @overload evolution_rate(start, finish, service = nil)
+        #     Returns the evolution rate of the item's state between two points in time
+        #     @param [#to_zoned_date_time] start The point in time from which to search
+        #     @param [#to_zoned_date_time] finish The point in time to which to search
+        #     @param [Symbol, String] service An optional persistence id instead of the default persistence service.
+        #     @return [DecimalType, QuantityType, nil] The evolution rate between `start` and `finish`,
+        #       or nil if no previous state could be found.
 
         # @!method historic_state(timestamp, service = nil)
         #   Returns the the item's state at the given time
@@ -317,6 +327,40 @@ module OpenHAB
           end
         end
 
+        # evolution_rate's "between" method is overloaded with the same name
+        method = :evolution_rate
+        define_method(method) do |start, finish_or_service = nil, service = nil|
+          if service.nil?
+            if finish_or_service.respond_to?(:to_zoned_date_time)
+              service = persistence_service
+              finish = finish_or_service
+            else
+              service = finish_or_service || persistence_service
+              finish = nil
+            end
+          else
+            finish = finish_or_service
+          end
+
+          result = if finish
+                     Actions::PersistenceExtensions.public_send(
+                       method,
+                       self,
+                       start.to_zoned_date_time,
+                       finish.to_zoned_date_time,
+                       service&.to_s
+                     )
+                   else
+                     Actions::PersistenceExtensions.public_send(
+                       method,
+                       self,
+                       start.to_zoned_date_time,
+                       service&.to_s
+                     )
+                   end
+          wrap_result(result, method)
+        end
+
         alias_method :state_changes_since, :count_state_changes_since
         alias_method :state_changes_between, :count_state_changes_between
 

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

@@ -59,16 +59,25 @@ module OpenHAB
         #
         # The item must be a managed item (typically created by Ruby or in the UI).
         #
+        # Any associated metadata or channel links are also removed.
+        #
         # @param [String, Item] item_name
         # @param recursive [true, false] Remove the item's members if it's a group
         # @return [Item, nil] The removed item, if found.
         def remove(item_name, recursive: false)
           item_name = item_name.name if item_name.is_a?(Item)
           provider = Provider.registry.provider_for(item_name)
-          unless provider.is_a?(org.openhab.core.common.registry.ManagedProvider)
+          unless provider.is_a?(ManagedProvider)
             raise "Cannot remove item #{item_name} from non-managed provider #{provider.inspect}"
           end
 
+          Metadata::Provider.registry.providers.grep(ManagedProvider).each do |managed_provider|
+            managed_provider.remove_item_metadata(item_name)
+          end
+
+          Things::Links::Provider.registry.providers.grep(ManagedProvider).each do |managed_provider|
+            managed_provider.remove_links_for_item(item_name)
+          end
           provider.remove(item_name, recursive)
         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/state_storage.rb

@@ -12,13 +12,13 @@ module OpenHAB
         #
         # Create a StateStorage object that stores the states of the given items
         #
-        # @param [Array<Item>] items A list of items
+        # @param [Item] items A list of items
         #
         # @return [StateStorage] A state storage object
         #
         # @!visibility private
         def self.from_items(*items)
-          StateStorage.new($events.store_states(*items).to_h)
+          StateStorage.new($events.store_states(*items.map(&:to_java)).to_h)
         end
 
         #

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

@@ -120,6 +120,11 @@ module OpenHAB
         # define a sub-class of EventSubscriber as a child class of the including class
         klass.const_set(:EventSubscriber, Class.new(EventSubscriber))
       end
+
+      # @!visibility private
+      def to_java
+        __getobj__
+      end
     end
   end
 end

data/lib/openhab/core/registry.rb

@@ -4,7 +4,7 @@ module OpenHAB
   module Core
     Registry = org.openhab.core.common.registry.AbstractRegistry
 
-    Registry.field_reader :elementToProvider, :elementReadLock, :identifierToElement
+    Registry.field_reader :elementToProvider, :elementReadLock, :identifierToElement, :providerToElements
 
     # @abstract
     #
@@ -19,12 +19,22 @@ module OpenHAB
       #
       def provider_for(key)
         elementReadLock.lock
-        return nil unless (element = identifierToElement[key])
+        if key.is_a?(org.openhab.core.common.registry.Identifiable)
+          element = key
+        else
+          return nil unless (element = identifierToElement[key])
+        end
 
         elementToProvider[element]
       ensure
         elementReadLock.unlock
       end
+
+      # @!attribute [r] providers
+      # @return [Enumerable<org.openhab.core.common.registry.Provider>]
+      def providers
+        providerToElements.keys
+      end
     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/rules.rb

@@ -13,7 +13,7 @@ module OpenHAB
 
       class << self
         #
-        # @!attribute [r] rule_manager
+        # @!attribute [r] manager
         # @return [org.openhab.core.automation.RuleManager] The openHAB rule manager/engine
         #
         def manager

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/links/provider.rb

@@ -33,6 +33,44 @@ module OpenHAB
               current.add(link)
             end
           end
+
+          #
+          # Removes all links to a given item.
+          #
+          # @param [String] item_name
+          # @return [Integer] how many links were removed
+          #
+          def remove_links_for_item(item_name)
+            count = 0
+            @elements.delete_if do |_k, v|
+              next unless v.item_name == item_name
+
+              count += 1
+              notify_listeners_about_removed_element(v)
+              true
+            end
+            count
+          end
+          alias_method :removeLinksForItem, :remove_links_for_item
+
+          #
+          # Removes all links to a given thing.
+          #
+          # @param [ThingUID] thing_uid
+          # @return [Integer] how many links were removed
+          #
+          def remove_links_for_thing(thing_uid)
+            count = 0
+            @elements.delete_if do |_k, v|
+              next unless v.linked_uid.thing_uid == thing_uid
+
+              count += 1
+              notify_listeners_about_removed_element(v)
+              true
+            end
+            count
+          end
+          alias_method :removeLinksForThing, :remove_links_for_thing
         end
       end
     end

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/things/registry.rb

@@ -61,6 +61,10 @@ module OpenHAB
             raise "Cannot remove thing #{thing_uid} from non-managed provider #{provider.inspect}"
           end
 
+          Links::Provider.registry.providers.grep(ManagedProvider).each do |managed_provider|
+            managed_provider.remove_links_for_thing(thing_uid)
+          end
+
           provider.remove(thing_uid)
         end
       end

data/lib/openhab/core/timer.rb

@@ -28,7 +28,7 @@ module OpenHAB
       #   @return [true,false]
 
       def_delegator :@timer, :has_terminated, :terminated?
-      def_delegators :@timer, :active?, :cancelled?, :running?
+      def_delegators :@timer, :active?, :cancelled?, :running?, :execution_time
 
       # @return [Object, nil]
       attr_accessor :id
@@ -49,19 +49,7 @@ module OpenHAB
         @id = id
         @thread_locals = thread_locals
         @block = block
-        @timer = if defined?(ScriptExecution)
-                   ScriptExecution.create_timer(1.minute.from_now) { execute }
-                 else # DEPRECATED: openHAB 3.4.0
-                   org.openhab.core.model.script.actions.ScriptExecution.create_timer(
-                     # create it far enough in the future so it won't execute until we finish setting it up
-                     1.minute.from_now,
-                     # when running in rspec, it may have troubles finding this class
-                     # for auto-conversion of block to interface, so use .impl
-                     org.eclipse.xtext.xbase.lib.Procedures::Procedure0.impl { execute }
-                   )
-                 end
-        # DEPRECATED: openHAB 3.4.0.M6
-        @timer.class.field_reader :future unless @timer.respond_to?(:future)
+        @timer = ScriptExecution.create_timer(1.minute.from_now) { execute }
         reschedule(@time)
       end
 
@@ -79,11 +67,7 @@ module OpenHAB
       alias_method :to_s, :inspect
 
       # @!attribute [r] execution_time
-      # @return [ZonedDateTime, nil] the scheduled execution time, or `nil` if the timer was cancelled
-      def execution_time
-        # DEPRECATED: openHAB 3.4.0.M6 (just remove the entire method)
-        @timer.future.scheduled_time
-      end
+      #   @return [ZonedDateTime, nil] the scheduled execution time, or `nil` if the timer was cancelled
 
       #
       # Reschedule timer

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

@@ -46,7 +46,7 @@ module OpenHAB
           rescue java.lang.StringIndexOutOfBoundsException, java.lang.IllegalArgumentException => e
             # Try Ruby's Time.parse if DateTimeType parser fails
             begin
-              ::Time.parse(time_string).to_zoned_date_time
+              DateTimeType.new(::Time.parse(time_string).to_zoned_date_time)
             rescue ArgumentError
               raise ArgumentError, e.message
             end