openhab-jrubyscripting 5.0.0.rc1 → 5.0.0.rc2

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

@@ -6,36 +6,6 @@ module OpenHAB
     # Contains extensions to simplify working with {Core::Things::Thing Thing}s.
     #
     module Things
-      # Stores all things created in scripts, and notifies the ThingRegistry
-      # of their existence
-      # aa@!visibility private
-      class ThingProvider < org.openhab.core.common.registry.AbstractProvider
-        include org.openhab.core.thing.ThingProvider
-        include Singleton
-
-        def initialize
-          super
-
-          @things = []
-
-          $things.add_provider(self)
-          ScriptHandling.script_unloaded { $things.remove_provider(self) }
-        end
-
-        # Add a thing to this provider
-        def add(thing)
-          thing = thing.build
-          @things << thing
-          notify_listeners_about_added_element(thing)
-          thing
-        end
-
-        # Get all items in this provider
-        def getAll # rubocop:disable Naming/MethodName required by java interface
-          @things
-        end
-      end
-
       # A thing builder allows you to dynamically create OpenHAB thing at runtime.
       # This can be useful either to create things as soon as the script loads,
       # or even later based on a rule executing.
@@ -45,6 +15,13 @@ module OpenHAB
       #     thing "astro:sun:home", "Astro Sun Data", config: { "geolocation" => "0,0" }
       #   end
       class Builder
+        # @return [org.openhab.core.things.ManagedThingProvider]
+        attr_reader :provider
+
+        def initialize(provider)
+          @provider = Core::Things::Provider.current(provider)
+        end
+
         # Create a new Bridge
         # @see BridgeBuilder#initialize
         def bridge(*args, **kwargs, &block)
@@ -62,7 +39,7 @@ module OpenHAB
         def build(klass, *args, **kwargs, &block)
           builder = klass.new(*args, **kwargs)
           builder.instance_eval(&block) if block
-          thing = ThingProvider.instance.add(builder)
+          thing = provider.add(builder.build)
           thing = Core::Things::Proxy.new(thing)
           thing.enable(enabled: builder.enabled) unless builder.enabled.nil?
           thing

data/lib/openhab/dsl/thread_local.rb

@@ -11,6 +11,7 @@ module OpenHAB
 
       # Keys to persist
       KNOWN_KEYS = %i[
+        openhab_providers
         openhab_rule_uid
         openhab_rule_type
         openhab_units

data/lib/openhab/dsl/timer_manager.rb

@@ -11,7 +11,7 @@ module OpenHAB
     class TimerManager
       include Singleton
 
-      ScriptHandling.script_unloaded { instance.cancel_all }
+      Core::ScriptHandling.script_unloaded { instance.cancel_all }
 
       # @!visibility private
       def initialize
@@ -31,7 +31,10 @@ module OpenHAB
             # timer when one doesn't already exist
             next old_timer if !reschedule && old_timer
 
-            old_timer&.cancel
+            if old_timer
+              old_timer.cancel!
+              @timers.remove(old_timer)
+            end
             Core::Timer.new(duration, id: id, thread_locals: thread_locals, block: block)
           end
         end
@@ -55,7 +58,7 @@ module OpenHAB
         @timers.remove(timer)
         return unless timer.id
 
-        @timers_by_id.delete(timer.id)
+        @timers_by_id.remove(timer.id)
       end
 
       #
@@ -67,7 +70,9 @@ module OpenHAB
       def cancel(id)
         result = false
         @timers_by_id.compute_if_present(id) do |_key, timer|
-          result = timer.cancel
+          result = timer.cancel!
+          @timers.remove(timer)
+
           nil
         end
         result
@@ -127,7 +132,7 @@ module OpenHAB
       def schedule(id)
         @timers_by_id.compute(id) do |_key, timer|
           new_timer = yield timer
-          raise ArgumentError, "Block must return a timer or nil" unless timer.is_a?(Core::Timer) || timer.nil?
+          raise ArgumentError, "Block must return a timer or nil" unless new_timer.is_a?(Core::Timer) || new_timer.nil?
 
           if !new_timer.equal?(timer) && new_timer&.id
             raise ArgumentError,
@@ -136,8 +141,9 @@ module OpenHAB
 
           if timer&.cancelled?
             new_timer = nil
-          elsif new_timer.nil? && !timer&.cancelled?
-            timer&.cancel
+          elsif new_timer.nil? && timer && !timer.cancelled?
+            timer.cancel!
+            @timers.remove(timer)
           end
           next unless new_timer
 

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.rc1"
+    VERSION = "5.0.0.rc2"
   end
 end

data/lib/openhab/dsl.rb

@@ -30,7 +30,7 @@ module OpenHAB
     # include this before Core::Actions so that Core::Action's method_missing
     # takes priority
     include Core::EntityLookup
-    [Core::Actions, Rules::Terse, ScriptHandling].each do |mod|
+    [Core::Actions, Core::ScriptHandling, Rules::Terse].each do |mod|
       # make these available both as regular and class methods
       include mod
       singleton_class.include mod
@@ -84,14 +84,6 @@ module OpenHAB
         builder.name(name)
         logger.trace { builder.inspect }
         builder.build(script)
-      rescue Exception => e
-        if (defined?(::RSpec::Expectations::ExpectationNotMetError) &&
-            e.is_a?(::RSpec::Expectations::ExpectationNotMetError)) ||
-           (defined?(::RSpec::Mocks::MockExpectationError) && e.is_a?(::RSpec::Mocks::MockExpectationError))
-          raise e
-        end
-
-        builder.send(:logger).log_exception(e)
       end
     end
 
@@ -115,17 +107,13 @@ module OpenHAB
 
       builder = nil
       ThreadLocal.thread_local(openhab_rule_type: "script", openhab_rule_uid: id) do
-        begin
-          builder = Rules::Builder.new(block.binding)
-          builder.uid(id)
-          builder.tags(["Script"])
-          builder.name(name)
-          builder.script(&block)
-          logger.trace { builder.inspect }
-          builder.build(script)
-        end
-      rescue Exception => e
-        builder.send(:logger).log_exception(e)
+        builder = Rules::Builder.new(block.binding)
+        builder.uid(id)
+        builder.tags(["Script"])
+        builder.name(name)
+        builder.script(&block)
+        logger.trace { builder.inspect }
+        builder.build(script)
       end
     end
 
@@ -614,7 +602,7 @@ module OpenHAB
     #   properly restored.
     #
     # {unit!} calls are cumulative - additional calls will not erase the effects
-    # previous calls unless they are for the same dimension.
+    # of previous calls unless they are for the same dimension.
     #
     # @return [Hash<javax.measure.Dimension=>javax.measure.Unit>]
     #   the prior unit configuration
@@ -657,6 +645,129 @@ module OpenHAB
       old_units
     end
 
+    #
+    # Sets the implicit provider(s) for operations inside the block.
+    #
+    # @param (see #provider!)
+    # @yield [] The block will be executed in the context of the specified unit(s).
+    # @return [Object] the result of the block
+    #
+    # @example
+    #   provider(metadata: :persistent) do
+    #     Switch1.metadata[:last_status_from_service] = status
+    #   end
+    #
+    #   provider!(metadata: { last_status_from_service: :persistent }, Switch2: :persistent)
+    #   Switch1.metadata[:last_status_from_service] = status # this will persist in JSONDB
+    #   Switch1.metadata[:homekit] = "Lightbulb" # this will be removed when the script is deleted
+    #   Switch2.metadata[:homekit] = "Lightbulb" # this will persist in JSONDB
+    #
+    # @see provider!
+    # @see OpenHAB::Core::Provider.current Provider.current for how the current provider is calculated
+    #
+    def provider(*args, **kwargs)
+      raise ArgumentError, "You must give a block to set the provider for the duration of" unless block_given?
+
+      begin
+        old_providers = provider!(*args, **kwargs)
+        yield
+      ensure
+        Thread.current[:openhab_providers] = old_providers
+      end
+    end
+
+    #
+    # Permanently set the implicit provider(s) for this thread.
+    #
+    # @note This method is only intended for use at the top level of rule
+    #   scripts. If it's used within library methods, or hap-hazardly within
+    #   rules, things can get very confusing because the prior state won't be
+    #   properly restored.
+    #
+    # {provider!} calls are cumulative - additional calls will not erase the effects
+    # of previous calls unless they are for the same provider type.
+    #
+    # @overload provider!(things: nil, items: nil, metadata: nil, links: nil, **metadata_items)
+    #
+    # @param [Core::Provider, org.openhab.core.registry.common.ManagedProvider, :persistent, :transient, Proc] providers
+    #   An explicit provider to use. If it's a {Core::Provider}, the type will be inferred automatically.
+    #   Otherwise it's applied to all types.
+    # @param [Hash] providers_by_type
+    #     A list of providers by type. Type can be `:items`, `:metadata`, `:things`, `:links`,
+    #     a {GenericItem} applying the provider to all metadata on that item, or a String or Symbol
+    #     applying the provider to all metadata of that namespace.
+    #
+    #     The provider can be a {org.openhab.core.common.registry.Provider Provider}, `:persistent`,
+    #     `:transient`, or a Proc returning one of those types. When the Proc is called for metadata
+    #     elements, the {Core::Items::Metadata::Hash} will be passed as an argument. Therefore it's
+    #     recommended that you use a Proc, not a Lambda, for permissive argument matching.
+    #
+    # @return [void]
+    #
+    # @see provider
+    # @see OpenHAB::Core::Provider.current Provider.current for how the current provider is calculated
+    #
+    def provider!(*providers, **providers_by_type)
+      thread_providers = Thread.current[:openhab_providers] ||= {}
+      old_providers = thread_providers.dup
+
+      providers.each do |provider|
+        case provider
+        when Core::Provider
+          thread_providers[provider.class.type] = provider
+        when org.openhab.core.common.registry.ManagedProvider
+          type = provider.type
+          unless type
+            raise ArgumentError, "#{provider.inspect} is for objects which are not supported by openhab-jrubyscripting"
+          end
+
+          thread_providers[type] = provider
+        when Proc,
+          :transient,
+          :persistent
+          Core::Provider::KNOWN_TYPES.each do |known_type|
+            thread_providers[known_type] = provider
+          end
+        when Hash
+          # non-symbols can't be used as kwargs, so Item keys show up as a separate hash here
+          # just merge it in, and allow it to be handled below
+          providers_by_type.merge!(provider)
+        else
+          raise ArgumentError, "#{provider.inspect} is not a valid provider"
+        end
+      end
+
+      providers_by_type.each do |type, provider|
+        case provider
+        when Proc,
+          org.openhab.core.common.registry.ManagedProvider,
+          :transient,
+          :persistent,
+          nil
+          nil
+        else
+          raise ArgumentError, "#{provider.inspect} is not a valid provider"
+        end
+
+        case type
+        when :items, :metadata, :things, :links
+          if provider.is_a?(org.openhab.core.common.registry.ManagedProvider) && provider.type != type
+            raise ArgumentError, "#{provider.inspect} is not a provider for #{type}"
+          end
+
+          thread_providers[type] = provider
+        when Symbol, String
+          (thread_providers[:metadata_namespaces] ||= {})[type.to_s] = provider
+        when GenericItem
+          (thread_providers[:metadata_items] ||= {})[type.name] = provider
+        else
+          raise ArgumentError, "#{type.inspect} is not provider type"
+        end
+      end
+
+      old_providers
+    end
+
     # @!visibility private
     def try_parse_time_like(string)
       return string unless string.is_a?(String)
@@ -675,7 +786,6 @@ module OpenHAB
 end
 
 OpenHAB::Core.wait_till_openhab_ready
-OpenHAB::Core.add_rubylib_to_load_path
 
 # import Items classes into global namespace
 OpenHAB::Core::Items.import_into_global_namespace

data/lib/openhab/log.rb

@@ -264,7 +264,7 @@ module OpenHAB
     def log_exception(exception)
       exception = clean_backtrace(exception)
       error do
-        "#{exception.message} (#{exception.class})\n#{name}#{exception.backtrace&.join("\n")}"
+        "#{exception.message} (#{exception.class})\n#{exception.backtrace&.join("\n")}"
       end
     end
 

data/lib/openhab/rspec/helpers.rb

@@ -208,7 +208,6 @@ module OpenHAB
         require "openhab/dsl"
 
         require_relative "mocks/persistence_service"
-        require_relative "mocks/metadata_provider"
         require_relative "mocks/timer"
 
         # override several DSL methods
@@ -400,34 +399,18 @@ module OpenHAB
       # need to transfer autoupdate metadata from GenericMetadataProvider to ManagedMetadataProvider
       # so that we can mutate it in the future
       def set_up_autoupdates
-        gmp = OSGi.service("org.openhab.core.model.item.internal.GenericMetadataProvider")
-        mr = Core::Items::Metadata::NamespaceHash.registry
-        mmp = mr.managed_provider.get
-        to_add = []
-        gmp.all.each do |metadata|
+        registry = Core::Items::Metadata::Provider.registry
+        registry.class.field_reader :identifierToElement
+
+        autoupdate_provider = Core::Items::Metadata::Provider.send(:new)
+        registry.all.each do |metadata|
           next unless metadata.uid.namespace == "autoupdate"
 
-          to_add << metadata
-        end
-        gmp.remove_metadata_by_namespace("autoupdate")
-
-        to_add.each do |m|
-          # we can't just update; we need to remove and add
-          # because this was a duplicate key, so the ManagedProvider
-          # knows about it, but the registry does not. So
-          # removing and adding gets it to notify the registry
-          # that it has it
-          mmp.remove(m.uid) if mmp.get(m.uid)
-          mmp.add(m)
+          # tweak the registry to allow us to overwrite this element
+          registry.identifierToElement.delete(metadata.uid)
+          autoupdate_provider.add(metadata)
         end
       end
-
-      def restore_autoupdate_items
-        return unless instance_variable_defined?(:@autoupdated_items)
-
-        @autoupdated_items&.each(&:commit)
-        @autoupdated_items = nil
-      end
     end
 
     if defined?(::RSpec)

data/lib/openhab/rspec/hooks.rb

@@ -41,28 +41,32 @@ module OpenHAB
           @known_rules = Core.rule_registry.all.map(&:uid)
         end
 
+        # Each spec gets temporary providers
+        [Core::Items::Provider,
+         Core::Items::Metadata::Provider,
+         Core::Things::Provider,
+         Core::Things::Links::Provider].each do |klass|
+          config.around do |example|
+            klass.new(&example)
+          end
+        end
+
         config.before do |example|
-          @item_provider = DSL::Items::ItemProvider.send(:new)
-          allow(DSL::Items::ItemProvider).to receive(:instance).and_return(@item_provider)
-          @thing_provider = DSL::Things::ThingProvider.send(:new)
-          allow(DSL::Things::ThingProvider).to receive(:instance).and_return(@thing_provider)
-          @item_channel_link_provider = DSL::Items::ItemChannelLinkProvider.send(:new)
-          allow(DSL::Items::ItemChannelLinkProvider).to receive(:instance).and_return(@item_channel_link_provider)
-          mr = Core::Items::Metadata::NamespaceHash.registry
-          @metadata_provider = Mocks::MetadataProvider.new(mr.managed_provider.get)
-          mr.add_provider(@metadata_provider)
-          mr.set_managed_provider(@metadata_provider)
+          # clear persisted thing status
           tm = OSGi.service("org.openhab.core.thing.ThingManager")
           tm.class.field_reader :storage
           tm.storage.keys.each { |k| tm.storage.remove(k) } # rubocop:disable Style/HashEachMethods not a hash
-          @log_index = File.size(log_file)
+
           profile_factory = Core::ProfileFactory.send(:new)
           @profile_factory_registration = OSGi.register_service(profile_factory)
           allow(Core::ProfileFactory).to receive(:instance).and_return(profile_factory)
+
           stub_const("OpenHAB::Core::Timer", Mocks::Timer) if self.class.mock_timers?
+
           log_line = "rspec #{example.location} # #{example.full_description}"
           logger.info(log_line)
           Logger.events.info(log_line)
+          @log_index = File.size(log_file)
         end
 
         config.after do
@@ -70,21 +74,14 @@ module OpenHAB
           (Core.rule_registry.all.map(&:uid) - @known_rules).each do |uid|
             remove_rule(uid) if defined?(remove_rule)
           end
-          $ir.remove_provider(@item_provider)
           Core::Items::Proxy.reset_cache
-          $things.remove_provider(@thing_provider)
           Core::Things::Proxy.reset_cache
-          registry = OSGi.service("org.openhab.core.thing.link.ItemChannelLinkRegistry")
-          registry.remove_provider(@item_channel_link_provider)
-          Core::Items::Metadata::NamespaceHash.registry.remove_provider(@metadata_provider)
-          @metadata_provider.restore_parent
           @profile_factory_registration.unregister
           timers.cancel_all
           # timers and rules have already been canceled, so we can safely just
           # wipe this
           DSL::Items::TimedCommand.timed_commands.clear
           Timecop.return
-          restore_autoupdate_items
           Mocks::PersistenceService.instance.reset
         end
       end

data/lib/openhab/rspec/mocks/timer.rb

@@ -70,6 +70,11 @@ module OpenHAB
           return false if terminated? || cancelled?
 
           DSL::TimerManager.instance.delete(self)
+          cancel!
+          true
+        end
+
+        def cancel!
           @execution_time = nil
           true
         end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: openhab-jrubyscripting
 version: !ruby/object:Gem::Version
-  version: 5.0.0.rc1
+  version: 5.0.0.rc2
 platform: ruby
 authors:
 - Cody Cutrer
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-11-17 00:00:00.000000000 Z
+date: 2022-11-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -336,10 +336,12 @@ files:
 - lib/openhab/core/items/metadata.rb
 - lib/openhab/core/items/metadata/hash.rb
 - lib/openhab/core/items/metadata/namespace_hash.rb
+- lib/openhab/core/items/metadata/provider.rb
 - lib/openhab/core/items/number_item.rb
 - lib/openhab/core/items/numeric_item.rb
 - lib/openhab/core/items/persistence.rb
 - lib/openhab/core/items/player_item.rb
+- lib/openhab/core/items/provider.rb
 - lib/openhab/core/items/proxy.rb
 - lib/openhab/core/items/registry.rb
 - lib/openhab/core/items/rollershutter_item.rb
@@ -350,12 +352,16 @@ files:
 - lib/openhab/core/items/switch_item.rb
 - lib/openhab/core/lazy_array.rb
 - lib/openhab/core/profile_factory.rb
+- lib/openhab/core/provider.rb
+- lib/openhab/core/registry.rb
 - lib/openhab/core/script_handling.rb
 - lib/openhab/core/things.rb
 - lib/openhab/core/things/channel.rb
 - lib/openhab/core/things/channel_uid.rb
 - lib/openhab/core/things/item_channel_link.rb
+- lib/openhab/core/things/links/provider.rb
 - lib/openhab/core/things/profile_callback.rb
+- lib/openhab/core/things/provider.rb
 - lib/openhab/core/things/proxy.rb
 - lib/openhab/core/things/registry.rb
 - lib/openhab/core/things/thing.rb
@@ -384,6 +390,7 @@ files:
 - lib/openhab/core/types/up_down_type.rb
 - lib/openhab/core/uid.rb
 - lib/openhab/core_ext.rb
+- lib/openhab/core_ext/java/class.rb
 - lib/openhab/core_ext/java/duration.rb
 - lib/openhab/core_ext/java/local_date.rb
 - lib/openhab/core_ext/java/local_time.rb
@@ -444,7 +451,6 @@ files:
 - lib/openhab/rspec/mocks/bundle_install_support.rb
 - lib/openhab/rspec/mocks/bundle_resolver.rb
 - lib/openhab/rspec/mocks/event_admin.rb
-- lib/openhab/rspec/mocks/metadata_provider.rb
 - lib/openhab/rspec/mocks/persistence_service.rb
 - lib/openhab/rspec/mocks/safe_caller.rb
 - lib/openhab/rspec/mocks/synchronous_executor.rb

data/lib/openhab/rspec/mocks/metadata_provider.rb

@@ -1,75 +0,0 @@
-# frozen_string_literal: true
-
-module OpenHAB
-  module RSpec
-    module Mocks
-      class MetadataProvider
-        org.openhab.core.common.registry.Identifiable
-        include org.openhab.core.items.ManagedMetadataProvider
-
-        def initialize(parent)
-          @metadata = {}
-          @listeners = []
-          @parent = parent
-          @removed_from_parent = []
-        end
-
-        def addProviderChangeListener(listener) # rubocop:disable Naming/MethodName required by java interface
-          @listeners << listener
-        end
-
-        def removeProviderChangeListener(listener) # rubocop:disable Naming/MethodName required by java interface
-          old = @listeners.delete(listener)
-          return unless old
-
-          @listeners.each { |l| l.removed(self, old) }
-        end
-
-        def add(metadata)
-          @metadata[metadata.uid] = metadata
-          @listeners.each { |l| l.added(self, metadata) }
-        end
-
-        def update(metadata)
-          old_element = @metadata[metadata.uid]
-          raise ArgumentError if old_element.nil?
-
-          @metadata[metadata.uid] = metadata
-          @listeners.each { |l| l.updated(self, old_element, metadata) }
-          metadata
-        end
-
-        def remove(key)
-          m = @parent.remove(key)
-          @removed_from_parent << m if m
-          m = @metadata.delete(key)
-          @listeners.each { |l| l.removed(self, m) } if m
-          m
-        end
-
-        def restore_parent
-          @removed_from_parent.each do |m|
-            @parent.add(m)
-          end
-        end
-
-        def get(key)
-          @metadata[key]
-        end
-
-        def getAll # rubocop:disable Naming/MethodName required by java interface
-          @metadata.values
-        end
-
-        def removeItemMetadata(item_name) # rubocop:disable Naming/MethodName required by java interface
-          @metadata.delete_if do |k, v|
-            next unless k.item_name == item_name
-
-            @listeners.each { |l| l.removed(self, v) }
-            true
-          end
-        end
-      end
-    end
-  end
-end