openhab-jrubyscripting 5.0.0.rc1 → 5.0.0.rc3

data/lib/openhab/dsl/thread_local.rb

@@ -11,11 +11,12 @@ module OpenHAB
 
       # Keys to persist
       KNOWN_KEYS = %i[
+        openhab_ensure_states
+        openhab_persistence_service
+        openhab_providers
         openhab_rule_uid
         openhab_rule_type
         openhab_units
-        openhab_persistence_service
-        openhab_ensure_states
       ].freeze
 
       #

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
 
@@ -179,9 +185,11 @@ module OpenHAB
       # @return [void]
       #
       def cancel_all
-        logger.trace("Canceling #{@timers.length} timers")
+        logged = false
         # don't use #each, in case timers are scheduling more timers
         until @timers.empty?
+          logger.trace("Canceling #{@timers.length} timers") unless logged
+          logged = true
           timer = @timers.keys.first
           timer.cancel
         end

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.rc3"
   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
@@ -41,92 +41,14 @@ module OpenHAB
 
     # @!group Rule Creation
 
-    #
-    # Create a new rule
-    #
-    # @param [String] name The rule name
-    # @yield Block executed in the context of a {Rules::Builder}
-    # @yieldparam [Rules::Builder] rule
-    #   Optional parameter to access the rule configuration from within execution blocks and guards.
-    # @return [org.openhab.core.automation.Rule] The OpenHAB Rule object
-    #
-    # @see OpenHAB::DSL::Rules::Builder Rule builder for details on rule triggers, guards and execution blocks
-    # @see Rules::Terse Terse Rules
-    #
-    # @example
-    #   require "openhab/dsl"
-    #
-    #   rule "name" do
-    #     <zero or more triggers>
-    #     <zero or more execution blocks>
-    #     <zero or more guards>
-    #   end
-    #
-    def rule(name = nil, id: nil, script: nil, binding: nil, &block)
-      raise ArgumentError, "Block is required" unless block
-
-      id ||= Rules::NameInference.infer_rule_id_from_name(name) if name
-      id ||= Rules::NameInference.infer_rule_id_from_block(block)
-      script ||= block.source rescue nil # rubocop:disable Style/RescueModifier
-
-      builder = nil
-
-      ThreadLocal.thread_local(openhab_rule_type: "rule", openhab_rule_uid: id) do
-        builder = Rules::Builder.new(binding || block.binding)
-        builder.uid(id)
-        builder.instance_exec(builder, &block)
-        builder.guard = Rules::Guard.new(run_context: builder.caller, only_if: builder.only_if,
-                                         not_if: builder.not_if)
-
-        name ||= Rules::NameInference.infer_rule_name(builder)
-        name ||= id
-
-        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
+    # (see Rules::Builder#rule)
+    def rule(name = nil, **kwargs, &block)
+      rules.build { rule(name, **kwargs, &block) }
     end
 
-    #
-    # Create a new script
-    #
-    # A script is a rule with no triggers. It can be called by various other actions,
-    # such as the Run Rules action.
-    #
-    # @param [String] id The script's ID
-    # @param [String] name A descriptive name
-    # @yield [] Block executed when the script is executed.
-    #
-    def script(name = nil, id: nil, script: nil, &block)
-      raise ArgumentError, "Block is required" unless block
-
-      id ||= Rules::NameInference.infer_rule_id_from_name(name) if name
-      id ||= Rules::NameInference.infer_rule_id_from_block(block)
-      name ||= id
-      script ||= block.source rescue nil # rubocop:disable Style/RescueModifier
-
-      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)
-      end
+    # (see Rules::Builder#script)
+    def script(name = nil, id: nil, **kwargs, &block)
+      rules.build { script(name, id: id, **kwargs, &block) }
     end
 
     # @!group Rule Support
@@ -182,44 +104,17 @@ module OpenHAB
       end
     end
 
-    #
-    # Remove a rule
-    #
-    # @param [String, org.openhab.core.automation.Rule] uid The rule UID or the Rule object to remove.
-    # @return [void]
-    #
-    # @example
-    #   my_rule = rule do
-    #     every :day
-    #     run { nil }
-    #   end
-    #
-    #   remove_rule(my_rule)
-    #
-    def remove_rule(uid)
-      uid = uid.uid if uid.respond_to?(:uid)
-      automation_rule = Rules.script_rules.delete(uid)
-      raise "Rule #{uid} doesn't exist to remove" unless automation_rule
-
-      automation_rule.cleanup
-      # automation_manager doesn't have a remove method, so just have to
-      # remove it directly from the provider
-      Rules.scripted_rule_provider.remove_rule(uid)
-    end
+    # @!group Object Access
 
     #
-    # Manually trigger a rule by ID
+    # Fetches all rules from the rule registry.
     #
-    # @param [String] uid The rule ID
-    # @param [Object, nil] event The event to pass to the rule's execution blocks.
-    # @return [void]
+    # @return [Core::Rules::Registry]
     #
-    def trigger_rule(uid, event = nil)
-      Rules.script_rules.fetch(uid).execute(nil, { "event" => event })
+    def rules
+      Core::Rules::Registry.instance
     end
 
-    # @!group Object Access
-
     #
     # Fetches all items from the item registry
     #
@@ -308,7 +203,7 @@ module OpenHAB
     # different files.
     #
     # @see timers
-    # @see Rules::Builder#changed
+    # @see Rules::BuilderDSL#changed
     # @see Items::TimedCommand
     #
     # @param [java.time.temporal.TemporalAmount, #to_zoned_date_time, Proc] duration
@@ -614,7 +509,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 +552,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 +693,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
 
@@ -332,8 +332,8 @@ module OpenHAB
         rule_type = Thread.current[:openhab_rule_type]
         full_id = "#{rule_type}:#{rule_uid}"
 
-        self.class.rule_loggers[full_id] ||= Logger.new("#{Logger::PREFIX}.#{rule_type}.#{rule_uid.tr_s(":", "_")
-            .gsub(/[^A-Za-z0-9_.-]/, "")}")
+        self.class.rule_loggers[full_id] ||= Logger.new("#{Logger::PREFIX}.#{rule_type}.#{rule_uid
+            .gsub(/[^A-Za-z0-9_.:-]/, "")}")
       end
 
       extend Forwardable

data/lib/openhab/rspec/example_group.rb

@@ -79,6 +79,48 @@ module OpenHAB
 
           true
         end
+
+        # @!attribute [w] propagate_exceptions
+        #
+        # Set if exceptions in rules should be propagated in specs, instead of just logged.
+        #
+        # @param value [true, false, nil]
+        # @return [true, false, nil]
+        #
+        # @example
+        #   describe "my_rule" do
+        #     self.propagate_exceptions = false
+        #
+        #     it "logs exceptions in rule execution" do
+        #       expect(self.class.propagate_exceptions?).to be false
+        #       rule do
+        #         on_start
+        #         run { raise "exception is logged" }
+        #       end
+        #       expect(spec_log_lines).to include(match(/exception is logged/))
+        #     end
+        #   end
+        #
+        def propagate_exceptions=(value)
+          @propagate_exceptions = value
+        end
+
+        #
+        # If timers are mocked for this example group
+        #
+        # It will search through parent groups until it finds one where it's
+        # explicitly defined, or defaults to `true` if none are.
+        #
+        # @return [true, false]
+        #
+        def propagate_exceptions?
+          if instance_variable_defined?(:@propagate_exceptions) && !@propagate_exceptions.nil?
+            return @propagate_exceptions
+          end
+          return superclass.propagate_exceptions? if superclass.is_a?(ClassMethods)
+
+          true
+        end
       end
 
       # @!visibility private

data/lib/openhab/rspec/helpers.rb

@@ -86,11 +86,16 @@ module OpenHAB
         end
 
         @autoupdated_items = []
+        @spec_metadata_provider = Core::Items::Metadata::Provider.current
 
         $ir.for_each do |_provider, item|
-          if (hash = item.metadata.delete("autoupdate"))
-            @autoupdated_items << hash
-            item.metadata["autoupdate"] = "true"
+          if (hash = item.metadata["autoupdate"])
+            provider = Core::Items::Metadata::Provider.registry.provider_for(hash.uid)
+            provider.remove(hash.uid)
+            @autoupdated_items << [provider, hash]
+            provider(@spec_metadata_provider) do
+              item.metadata["autoupdate"] = "true"
+            end
           end
         end
       end
@@ -142,13 +147,13 @@ module OpenHAB
       # @yield
       # @return [void]
       def wait(how_long = 2.seconds)
-        now = Time.now
+        start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
 
         begin
           yield
         rescue ::RSpec::Expectations::ExpectationNotMetError,
                ::RSpec::Mocks::MockExpectationError
-          raise if Time.now > now + how_long
+          raise if Process.clock_gettime(Process::CLOCK_MONOTONIC) > start + how_long.to_f
 
           sleep 0.1
           retry
@@ -177,6 +182,17 @@ module OpenHAB
       # @return [void]
       #
       def autorequires
+        ENV["RUBYLIB"] ||= ""
+        ENV["RUBYLIB"] += ":" unless ENV["RUBYLIB"].empty?
+        ENV["RUBYLIB"] += rubylib_dir
+
+        $LOAD_PATH.unshift(*ENV["RUBYLIB"]
+          .split(File::PATH_SEPARATOR)
+            .reject(&:empty?)
+            .reject do |path|
+                             $LOAD_PATH.include?(path)
+                           end)
+
         requires = jrubyscripting_config&.get("require") || ""
         requires.split(",").each do |f|
           require f.strip
@@ -202,13 +218,9 @@ module OpenHAB
         karaf.use_root_instance = use_root_instance
         main = karaf.launch
 
-        ENV["RUBYLIB"] ||= ""
-        ENV["RUBYLIB"] += ":" unless ENV["RUBYLIB"].empty?
-        ENV["RUBYLIB"] += rubylib_dir
         require "openhab/dsl"
 
         require_relative "mocks/persistence_service"
-        require_relative "mocks/metadata_provider"
         require_relative "mocks/timer"
 
         # override several DSL methods
@@ -400,32 +412,26 @@ 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.each do |(provider, hash)|
+          @spec_metadata_provider.remove(hash.uid)
+          provider.add(hash.instance_variable_get(:@metadata))
+        end
         @autoupdated_items = nil
       end
     end

data/lib/openhab/rspec/hooks.rb

@@ -38,46 +38,40 @@ module OpenHAB
               item.state = NULL unless item.raw_state == NULL
             end
           end
-          @known_rules = Core.rule_registry.all.map(&:uid)
+        end
+
+        # Each spec gets temporary providers
+        [Core::Items::Provider,
+         Core::Items::Metadata::Provider,
+         Core::Rules::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)
-          tm = OSGi.service("org.openhab.core.thing.ThingManager")
+          # clear persisted thing status
+          tm = Core::Things.manager
           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
-          # remove rules created during the spec
-          (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