openhab-jrubyscripting 5.0.0.rc1 → 5.0.0.rc2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cd7a4eed6a2398fd34734d9b3dc15a8f5e2bcc74f7309aede27be29501c21698
-  data.tar.gz: a1f70554ada415e7de0325ea259ac9edcad48355ef6000a4877057fa06b343ce
+  metadata.gz: 0e925ebd72648fa8efb76592f6053d12f2fe9151173fa91d3f47a2d298f268fc
+  data.tar.gz: 6d84217a8505a72e2da686188a741d6644eee645255595d5d2cf455a2840e015
 SHA512:
-  metadata.gz: f27aa8940df9441a5318c32d1c0d84f15fdd70b2336cf95dd09383b73b97d14bbc7c924ba3e3df24f48d5f289d410ec1d6d0df9f99a40141ac34d88152e9a76a
-  data.tar.gz: c369de38091c4486a492b88ef990537b5a4cc667becca6be5a99a56227a8a2b0339b14e9ce1e11e6e73b56d8b055d3876917916ee7ec52b66c5b23e85b33a95b
+  metadata.gz: 5330bd233b45839cf1780815e86d170ff8a33b4093debfe85cae7e09e631d7a14c7bb2c7e84500da6a41fd0b89f81a160e4279659312323e6fb207bd0da6e632
+  data.tar.gz: 28f42c9a625aa33ef258f4d789e9fe116a1bf36e63bc58e2574d1a884ed8bde74bac03484566abd04909462ec4c9bdef543973416a2420fa02fea274122e3889

data/lib/openhab/core/entity_lookup.rb

@@ -72,7 +72,7 @@ module OpenHAB
         logger.trace("Looking up thing '#{uid}'")
         uid = uid.to_s if uid.is_a?(Symbol)
 
-        uid = generate_thing_uid(uid) unless uid.is_a?(org.openhab.core.thing.ThingUID)
+        uid = Things::ThingUID.new(uid) unless uid.is_a?(Things::ThingUID)
         thing = $things.get(uid)
         return unless thing
 
@@ -117,17 +117,6 @@ module OpenHAB
         item = $ir.get(name)
         Items::Proxy.new(item) unless item.nil?
       end
-
-      #
-      # Returns a ThingUID given a string like object
-      #
-      # @!visibility private
-      #
-      # @return [Things::ThingUID]
-      #
-      def self.generate_thing_uid(uid)
-        org.openhab.core.thing.ThingUID.new(*uid.split(":"))
-      end
     end
   end
 end

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

@@ -73,7 +73,7 @@ module OpenHAB
         def command(command)
           command = format_command(command)
           logger.trace "Sending Command #{command} to #{name}"
-          org.openhab.core.model.script.actions.BusEvent.sendCommand(self, command)
+          $events.send_command(self, command)
           self
         end
 
@@ -93,7 +93,7 @@ module OpenHAB
         def update(state)
           state = format_update(state)
           logger.trace "Sending Update #{state} to #{name}"
-          org.openhab.core.model.script.actions.BusEvent.postUpdate(self, state)
+          $events.post_update(self, state)
           self
         end
 

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

@@ -15,6 +15,8 @@ module OpenHAB
         #
         # @!attribute [rw] value
         #   @return [String] The main value for the metadata namespace.
+        # @!attribute [r] namespace
+        #   @return [String]
         #
         class Hash
           java_import org.openhab.core.items.Metadata
@@ -58,6 +60,8 @@ module OpenHAB
                          :value?
           def_delegators :to_h, :invert, :merge, :transform_keys, :transform_values
 
+          def_delegator :uid, :namespace
+
           class << self
             # @!visibility private
             def from_item(item_name, namespace, value)
@@ -72,7 +76,7 @@ module OpenHAB
 
                         [value.first, (value.last || {}).transform_keys(&:to_s)]
                       when ::Hash then ["", value.transform_keys(&:to_s)]
-                      else [value, {}]
+                      else [value.to_s, {}]
                       end
               new(Metadata.new(org.openhab.core.items.MetadataKey.new(namespace.to_s, item_name), *value))
             end
@@ -108,13 +112,24 @@ module OpenHAB
           end
 
           # @!visibility private
-          def create
-            NamespaceHash.registry.add(@metadata) if attached?
+          def commit
+            return unless attached?
+
+            javaify
+            provider.update(@metadata)
           end
 
           # @!visibility private
-          def commit
-            NamespaceHash.registry.update(@metadata) if attached?
+          def create_or_update
+            return unless attached?
+
+            javaify
+            (p = provider).get(uid) ? p.update(@metadata) : p.add(@metadata)
+          end
+
+          # @!visibility private
+          def remove
+            provider.remove(uid)
           end
 
           # @!visibility private
@@ -383,6 +398,50 @@ module OpenHAB
             [value, to_h].inspect
           end
           alias_method :to_s, :inspect
+
+          #
+          # @raise [RuntimeError] if the provider is not a
+          #   {org.openhab.core.common.registry.ManagedProvider ManagedProvider} that can be updated.
+          # @return [org.openhab.core.common.registry.ManagedProvider]
+          #
+          def provider
+            preferred_provider = Provider.current(
+              Thread.current[:openhab_providers]&.dig(:metadata_items, uid.item_name) ||
+                Thread.current[:openhab_providers]&.dig(:metadata_namespaces, uid.namespace),
+              self
+            )
+
+            if attached?
+              provider = Provider.registry.provider_for(uid)
+              return preferred_provider unless provider
+
+              unless provider.is_a?(org.openhab.core.common.registry.ManagedProvider)
+                raise FrozenError, "Cannot modify metadata from provider #{provider.inspect}"
+              end
+
+              if preferred_provider != provider
+                logger.warn("Provider #{preferred_provider.inspect} cannot be used with #{uid}; " \
+                            "reverting to provider #{provider.inspect}. " \
+                            "This may cause unexpected issues, like metadata persisting that you did not expect to.")
+                preferred_provider = provider
+              end
+
+            end
+            preferred_provider
+          end
+
+          private
+
+          #
+          # @see https://github.com/openhab/openhab-core/issues/3169
+          #
+          # in the meantime, force the serialization round-trip right now
+          #
+          def javaify
+            mapper = Provider.registry.managed_provider.get.storage.entityMapper
+
+            @metadata = mapper.from_json(mapper.to_json_tree(@metadata), Metadata.java_class)
+          end
         end
       end
     end

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

@@ -96,12 +96,7 @@ module OpenHAB
             metadata = Hash.from_item(@item_name, namespace, value)
             return @hash[metadata.uid.namespace] = metadata unless attached? # rubocop:disable Lint/ReturnInVoidContext
 
-            # registry.get can be omitted, but registry.update will log a warning for nonexistent metadata
-            if self.class.registry.managed_provider.get.get(metadata.uid)
-              metadata.commit
-            else
-              metadata.create
-            end
+            metadata.create_or_update
             metadata # rubocop:disable Lint/Void
           end
           alias_method :store, :[]=
@@ -117,7 +112,11 @@ module OpenHAB
           # @!visibility private
           def clear
             if attached?
-              self.class.registry.remove_item_metadata(@item_name)
+              provider = Provider.current(Thread.current[:openhab_providers]&.dig(:metadata_items, @item_name))
+              provider.remove_item_metadata(@item_name)
+              Thread.current[:openhab_providers]&.[](:metadata_namespaces)&.each_value do |namespace_provider|
+                Provider.current(namespace_provider).remove_item_metadata(@item_name)
+              end
             else
               @hash.clear
             end
@@ -171,11 +170,10 @@ module OpenHAB
 
           # @!visibility private
           def delete(namespace, &block)
-            namespace = namespace.to_s
-
-            return @hash.delete(namespace, &block) unless attached?
+            return @hash.delete(namespace.to_s, &block) unless attached?
 
-            r = self.class.registry.remove(MetadataKey.new(namespace, @item_name))
+            metadata = Hash.from_item(@item_name, namespace, nil)
+            r = metadata.remove
             return yield(namespace) if block && !r
 
             Hash.new(r) if r
@@ -208,7 +206,7 @@ module OpenHAB
             return @hash.each(&block) unless attached?
             return to_enum(:each) unless block
 
-            self.class.registry.all.each do |meta|
+            Provider.registry.all.each do |meta|
               yield meta.uid.namespace, Hash.new(meta) if meta.uid.item_name == @item_name
             end
             self
@@ -220,7 +218,7 @@ module OpenHAB
             return @hash.each_key(&block) unless attached?
             return to_enum(:each_key) unless block
 
-            self.class.registry.all.each do |meta|
+            Provider.registry.all.each do |meta|
               yield meta.uid.namespace if meta.uid.item_name == @item_name
             end
             self
@@ -231,7 +229,7 @@ module OpenHAB
             return @hash.each_value(&block) unless attached?
             return to_enum(:each_value) unless block_given?
 
-            self.class.registry.all.each do |meta|
+            Provider.registry.all.each do |meta|
               yield Hash.new(meta) if meta.uid.item_name == @item_name
             end
             self
@@ -241,7 +239,7 @@ module OpenHAB
           def empty?
             return @hash.empty? unless attached?
 
-            self.class.registry.all.each do |meta|
+            Provider.registry.all.each do |meta|
               return false if meta.uid.item_name == @item_name
             end
             true
@@ -263,7 +261,7 @@ module OpenHAB
             end
 
             logger.trace("Getting metadata for item: #{@item_name}, namespace '#{key}'")
-            if (m = self.class.registry.get(MetadataKey.new(key, @item_name)))
+            if (m = Provider.registry.get(MetadataKey.new(key, @item_name)))
               Hash.new(m)
             elsif block
               yield key
@@ -280,7 +278,7 @@ module OpenHAB
 
             keys.each_with_object([]) do |key, res|
               key = key.to_s
-              if (m = self.class.registry.get(MetadataKey.new(key, @item_name)))
+              if (m = Provider.registry.get(MetadataKey.new(key, @item_name)))
                 res << Hash.new(m)
               elsif block_given?
                 res << yield(key)
@@ -307,7 +305,7 @@ module OpenHAB
             key = key.to_s
             return @hash.key?(key) unless attached?
 
-            !self.class.registry.get(MetadataKey.new(key, @item_name)).nil?
+            !Provider.registry.get(MetadataKey.new(key, @item_name)).nil?
           end
           alias_method :has_key?, :key?
           alias_method :member?, :key?
@@ -373,7 +371,7 @@ module OpenHAB
 
             keys = keys.to_set
             r = {}
-            self.class.registry.all.each do |meta|
+            Provider.registry.all.each do |meta|
               if meta.uid.item_name == @item_name && keys.include?(meta.uid.namespace)
                 r[meta.uid.namespace] =
                   Hash.new(meta)

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

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module OpenHAB
+  module Core
+    module Items
+      module Metadata
+        #
+        # Provides metadata created in Ruby to openHAB
+        #
+        class Provider < Core::Provider
+          include org.openhab.core.items.ManagedMetadataProvider
+
+          class << self
+            #
+            # The Metadata registry
+            #
+            # @return [org.openhab.core.items.MetadataRegistry]
+            #
+            def registry
+              @registry ||= OSGi.service("org.openhab.core.items.MetadataRegistry")
+            end
+          end
+
+          # see Hash#javaify
+          registry.managed_provider.get.class.field_reader :storage
+          registry.managed_provider.get.storage.class.field_reader :entityMapper
+
+          #
+          # Removes all metadata of a given item.
+          #
+          # @param [String] item_name
+          # @return [void]
+          #
+          def remove_item_metadata(item_name)
+            @elements.delete_if do |k, v|
+              next unless k.item_name == item_name
+
+              notify_listeners_about_removed_element(v)
+              true
+            end
+            nil
+          end
+          alias_method :removeItemMetadata, :remove_item_metadata
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module OpenHAB
+  module Core
+    module Items
+      #
+      # Provides {GenericItem Items} created in Ruby to openHAB
+      #
+      class Provider < Core::Provider
+        include org.openhab.core.items.ItemProvider
+
+        class << self
+          #
+          # The Item registry
+          #
+          # @return [org.openhab.core.items.ItemRegistry]
+          #
+          def registry
+            $ir
+          end
+        end
+
+        #
+        # Remove an item from this provider
+        #
+        # @param [String] item_name
+        # @param [true, false] recursive
+        # @return [GenericItem, nil] The removed item, if found.
+        #
+        def remove(item_name, recursive = false) # rubocop:disable Style/OptionalBooleanParameter matches Java method
+          return nil unless @elements.key?(item_name)
+
+          item = super(item_name)
+          item.members.each { |member| remove(member.name, true) } if recursive && item.is_a?(GroupItem)
+          item
+        end
+      end
+    end
+  end
+end

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

@@ -53,6 +53,16 @@ module OpenHAB
 
           super
         end
+
+        #
+        # Non equality comparison
+        #
+        # @return [true, false]
+        #
+        # @!visibility private
+        def !=(other)
+          !(self == other) # rubocop:disable Style/InverseMethods
+        end
       end
     end
   end

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

@@ -32,6 +32,8 @@ module OpenHAB
           !$ir.getItems(name).empty?
         end
         alias_method :include?, :key?
+        # @deprecated
+        alias_method :has_key?, :key?
 
         # Explicit conversion to array
         # @return [Array]
@@ -39,26 +41,33 @@ module OpenHAB
           $ir.items.map { |item| Proxy.new(item) }
         end
 
+        #
         # Enter the Item Builder DSL.
+        #
+        # @param (see Core::Provider.current)
         # @yield Block executed in the context of a {DSL::Items::Builder}
         # @return [Object] The return value of the block.
-        def build(&block)
-          DSL::Items::BaseBuilderDSL.new.instance_eval(&block)
+        #
+        def build(preferred_provider = nil, &block)
+          DSL::Items::BaseBuilderDSL.new(preferred_provider).instance_eval(&block)
         end
 
+        #
         # Remove an item.
         #
-        # The item must have either been created by this script, or be a
-        # managed item (typically created in the UI).
+        # The item must be a managed item (typically created by Ruby or in the UI).
         #
+        # @param [String, GenericItem] item_name
         # @param recursive [true, false] Remove the item's members if it's a group
         # @return [GenericItem, nil] The removed item, if found.
         def remove(item_name, recursive: false)
           item_name = item_name.name if item_name.is_a?(GenericItem)
-          result = DSL::Items::ItemProvider.instance.remove(item_name, recursive: recursive)
-          return result if result
+          provider = Provider.registry.provider_for(item_name)
+          unless provider.is_a?(org.openhab.core.common.registry.ManagedProvider)
+            raise "Cannot remove item #{item_name} from non-managed provider #{provider.inspect}"
+          end
 
-          $ir.remove(item_name, recursive)
+          provider.remove(item_name, recursive)
         end
       end
     end

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

@@ -18,7 +18,7 @@ module OpenHAB
         #
         # @!visibility private
         def self.from_items(*items)
-          StateStorage.new(org.openhab.core.model.script.actions.BusEvent.store_states(*items).to_h)
+          StateStorage.new($events.store_states(*items).to_h)
         end
 
         #
@@ -27,7 +27,7 @@ module OpenHAB
         # @return [void]
         #
         def restore
-          org.openhab.core.model.script.actions.BusEvent.restore_states(to_h)
+          $events.restore_states(to_h)
         end
 
         #
@@ -36,7 +36,7 @@ module OpenHAB
         # @return [void]
         #
         def restore_changes
-          org.openhab.core.model.script.actions.BusEvent.restore_states(select { |item, value| item.state != value })
+          $events.restore_states(select { |item, value| item.state != value })
         end
 
         #

data/lib/openhab/core/profile_factory.rb

@@ -113,6 +113,6 @@ module OpenHAB
     end
 
     registration = OSGi.register_service(ProfileFactory.instance)
-    ScriptHandlingCallbacks.script_unloaded_hooks << -> { registration.unregister }
+    ScriptHandling.script_unloaded { registration.unregister }
   end
 end

data/lib/openhab/core/provider.rb

@@ -0,0 +1,216 @@
+# frozen_string_literal: true
+
+require "singleton"
+
+module OpenHAB
+  module Core
+    # @interface
+    java_import org.openhab.core.common.registry.ManagedProvider
+
+    # @!visibility private
+    module ManagedProvider
+      # Maps actual element types to the symbol used in Thread.local[:openhab_providers]
+      TYPE_TO_PROVIDER_TYPE = {
+        org.openhab.core.items.Item.java_class => :items,
+        org.openhab.core.items.Metadata.java_class => :metadata,
+        org.openhab.core.thing.Thing.java_class => :things,
+        org.openhab.core.thing.link.ItemChannelLink.java_class => :links
+      }.freeze
+      private_constant :TYPE_TO_PROVIDER_TYPE
+
+      # @return [Symbol, nil]
+      def type
+        java_class.generic_ancestors.each do |klass|
+          next unless klass.respond_to?(:raw_type)
+          next unless klass.raw_type == org.openhab.core.common.registry.Provider.java_class
+
+          type_arg = klass.actual_type_arguments.first
+          next unless type_arg.is_a?(java.lang.Class)
+          next unless klass.actual_type_arguments.first.is_a?(java.lang.Class)
+
+          return TYPE_TO_PROVIDER_TYPE[type_arg]
+        end
+        nil
+      end
+    end
+
+    # @abstract
+    class Provider < org.openhab.core.common.registry.AbstractProvider
+      include org.openhab.core.common.registry.ManagedProvider
+      include Singleton
+      public_class_method :new
+
+      # Known supported provider types
+      # @return [Array<Symbol>]
+      KNOWN_TYPES = %i[items metadata things links].freeze
+
+      class << self
+        #
+        # Determines the current provider that should be used to create elements belonging to this registry.
+        #
+        # @param [org.openhab.core.common.registry.Provider, Proc, :persistent, :transient, nil] preferred_provider
+        #   An optional preferred provider to use. Can be one of several types:
+        #    * An explicit instance of {org.openhab.core.common.registry.ManagedProvider ManagedProvider}
+        #    * A Proc, which can calculate the preferred provider based on whatever conditions it wants,
+        #      and then is further processed as this parameter.
+        #    * `:persistent`, meaning the default {org.openhab.core.common.registry.ManagedProvider ManagedProvider}
+        #      for this registry. Managed providers persist their objects to JSON, and will survive after the
+        #      Ruby script is unloaded. This is where objects you configure with MainUI are stored. You should
+        #      use this provider when you're creating something in response to a one-time event.
+        #    * `:transient`, meaning a {org.openhab.core.common.registry.ManagedProvider ManagedProvider} that
+        #      will remove all of its contents when the Ruby script is unloaded. You should use this if you're
+        #      generating objects dynamically, either based on some sort of other configuration, or simply
+        #      hard coded and you're using Ruby as a more expressive way to define things than a `.items` or
+        #      `.things` file. If you _don't_ use this provider for something such as metadata, then you
+        #      may have issues such as metadata still showing up even though you're no longer creating items
+        #      with it anymore.
+        #    * `nil`, meaning to fall back to the current thread setting. See {OpenHAB::DSL.provider}.
+        #      If there is no thread setting (or the thread setting was Proc that returned `nil`),
+        #      it defaults to `:transient`.
+        # @return [org.openhab.core.common.registry.Provider]
+        #
+        def current(preferred_provider = nil, element = nil)
+          preferred_provider ||= Thread.current[:openhab_providers]&.[](type)
+          if preferred_provider.is_a?(Proc)
+            preferred_provider = if preferred_provider.arity.zero? || element.nil?
+                                   preferred_provider.call
+                                 else
+                                   preferred_provider.call(element)
+                                 end
+          end
+
+          case preferred_provider
+          when nil, :transient
+            instance
+          when :persistent
+            registry.managed_provider.get
+          when org.openhab.core.common.registry.ManagedProvider
+            preferred_provider
+          else
+            raise ArgumentError, "#{preferred_provider.inspect} is not a ManagedProvider"
+          end
+        end
+
+        # @abstract
+        # @!attribute [r] registry
+        #
+        # The registry that this provider provides elements for.
+        #
+        # @return [org.openhab.core.common.registry.Registry]
+        #
+        def registry
+          raise NotImplementedError
+        end
+
+        #
+        # Creates a new instance of a provider, registers it, sets it as the
+        # default for the thread, calls the block, and then unregisters it.
+        #
+        # @param [true, false] thread_provider Set this new provider as the default for the thread
+        # @yieldparam [Provider] provider The provider
+        # @return [Object] The result of the block
+        #
+        # @!visibility private
+        def new(thread_provider: true)
+          unless @singleton__instance__.nil? || block_given?
+            raise NoMethodError,
+                  "private method `new' called for #{self}:Class"
+          end
+
+          r = provider = super()
+          if block_given?
+            if thread_provider
+              DSL.provider(provider) do
+                r = yield provider
+              end
+            else
+              r = yield provider
+            end
+            provider.unregister
+          end
+          r
+        end
+
+        # @!attribute [r] type
+        # @!visibility private
+        # @return [Symbol]
+        #
+        def type
+          name.split("::")[-2].downcase.to_sym
+        end
+      end
+
+      # @return [String]
+      def inspect
+        "#<#{self.class.name}:#{object_id}>"
+      end
+
+      # @!visibility private
+      def add(element)
+        @elements[element.uid] = element
+        notify_listeners_about_added_element(element)
+        element
+      end
+
+      #
+      # Get an element from this provider
+      #
+      # @param [Object] key The proper key type for the elements in this provider.
+      # @return [Object]
+      #
+      def [](key)
+        @elements[key]
+      end
+      alias_method :get, :[]
+
+      #
+      # Get all elements in this provider
+      #
+      # @return [Array<Object>]
+      #
+      def all
+        @elements.values
+      end
+      alias_method :getAll, :all
+
+      #
+      # Remove an element from this provider
+      #
+      # @return [Object, nil] the removed element
+      #
+      # @!visibility private
+      #
+      def remove(key)
+        @elements.delete(key)&.tap do |element|
+          notify_listeners_about_removed_element(element)
+        end
+      end
+
+      # @return [Object, nil] the previous version of the element
+      # @!visibility private
+      #
+      def update(element)
+        old_element = @elements[element.uid]
+        if old_element
+          @elements[element.uid]
+          notify_listeners_about_updated_element(old_element, element)
+        end
+        old_element
+      end
+
+      # @!visibility private
+      def unregister
+        self.class.registry.remove_provider(self)
+      end
+
+      private
+
+      def initialize
+        super
+        @elements = {}
+        self.class.registry.add_provider(self)
+        ScriptHandling.script_unloaded { unregister }
+      end
+    end
+  end
+end