openhab-jrubyscripting 5.0.0.rc2 → 5.0.0.rc3

data/lib/openhab/dsl/rules/triggers/conditions/duration.rb

@@ -6,19 +6,12 @@ module OpenHAB
       module Triggers
         # @!visibility private
         module Conditions
-          #
-          # this is a no-op condition which simply executes the provided block
-          #
-
           #
           # Struct capturing data necessary for a conditional trigger
           #
-          # TriggerDelay = Struct.new(:to, :from, :duration, :timer, :tracking_to, keyword_init: true) do
-          #  def timer_active?
-          #    timer&.active?
-          #  end
-          # end
           class Duration
+            attr_accessor :rule
+
             #
             # Create a new duration condition
             # @param [Object] to optional condition on to state
@@ -39,7 +32,17 @@ module OpenHAB
             # @param [Hash] inputs inputs from trigger
             #
             def process(mod:, inputs:, &block)
-              process_trigger_delay(mod, inputs, &block)
+              if @timer&.active?
+                process_active_timer(inputs, mod, &block)
+              elsif check_trigger_guards(inputs)
+                logger.trace("Trigger Guards Matched for #{self}, delaying rule execution")
+                # Add timer and attach timer to delay object, and also state being tracked to so
+                # timer can be cancelled if state changes
+                # Also another timer should not be created if changed to same value again but instead rescheduled
+                create_trigger_delay_timer(inputs, mod, &block)
+              else
+                logger.trace("Trigger Guards did not match for #{self}, ignoring trigger.")
+              end
             end
 
             # Cleanup any resources from the condition
@@ -51,13 +54,6 @@ module OpenHAB
 
             private
 
-            #
-            # Checks if there is an active timer
-            # @return [true, false] true if the timer exists and is active, false otherwise
-            def timer_active?
-              @timer&.active?
-            end
-
             #
             # Check if trigger guards prevent rule execution
             #
@@ -79,44 +75,12 @@ module OpenHAB
             # @return [Array] An array of the values for [newState, oldState] or [newStatus, oldStatus]
             #
             def retrieve_states(inputs)
-              new_state = inputs["newState"] || thing_status_to_sym(inputs["newStatus"])
-              old_state = inputs["oldState"] || thing_status_to_sym(inputs["oldStatus"])
+              new_state = inputs["newState"] || inputs["newStatus"]&.to_s&.downcase&.to_sym
+              old_state = inputs["oldState"] || inputs["oldStatus"]&.to_s&.downcase&.to_sym
 
               [new_state, old_state]
             end
 
-            #
-            # Converts a ThingStatus object to a ruby Symbol
-            #
-            # @param [org.openhab.core.thing.ThingStatus] status A ThingStatus instance
-            #
-            # @return [Symbol] A corresponding symbol, in lower case
-            #
-            def thing_status_to_sym(status)
-              status&.to_s&.downcase&.to_sym
-            end
-
-            #
-            # Process any matching trigger delays
-            #
-            # @param [Map] mod OpenHAB map object describing rule trigger
-            # @param [Map] inputs OpenHAB map object describing rule trigger
-            #
-            #
-            def process_trigger_delay(mod, inputs, &block)
-              if timer_active?
-                process_active_timer(inputs, mod, &block)
-              elsif check_trigger_guards(inputs)
-                logger.trace("Trigger Guards Matched for #{self}, delaying rule execution")
-                # Add timer and attach timer to delay object, and also state being tracked to so
-                # timer can be cancelled if state changes
-                # Also another timer should not be created if changed to same value again but instead rescheduled
-                create_trigger_delay_timer(inputs, mod, &block)
-              else
-                logger.trace("Trigger Guards did not match for #{self}, ignoring trigger.")
-              end
-            end
-
             #
             # Creates a timer for trigger delays
             #
@@ -131,6 +95,7 @@ module OpenHAB
                 @timer = nil
                 yield
               end
+              rule.on_removal(self)
               @tracking_to, = retrieve_states(inputs)
             end
 
@@ -140,7 +105,6 @@ module OpenHAB
             # @param [Hash] inputs rule trigger inputs
             # @param [Hash] mod rule trigger mods
             #
-            #
             def process_active_timer(inputs, mod, &block)
               state, = retrieve_states(inputs)
               if state == @tracking_to
@@ -150,7 +114,7 @@ module OpenHAB
                 logger.trace("Item changed to #{state} for #{self}, canceling timer.")
                 @timer.cancel
                 # Reprocess trigger delay after canceling to track new state (if guards matched, etc)
-                process_trigger_delay(mod, inputs, &block)
+                process(mod: mod, inputs: inputs, &block)
               end
             end
           end

data/lib/openhab/dsl/rules/triggers/conditions/proc.rb

@@ -84,9 +84,6 @@ module OpenHAB
               yield if check_procs(inputs: inputs)
             end
 
-            # Cleanup any resources from the condition
-            def cleanup; end
-
             #
             # Check if command condition match the proc
             # @param [Hash] inputs from trigger must be supplied if state is not supplied

data/lib/openhab/dsl/rules/triggers/watch/watch_handler.rb

@@ -98,8 +98,8 @@ module OpenHAB
             #
             def watch_event_handler(glob)
               lambda { |watch_event|
-                logger.trace("Received event(#{watch_event})")
                 if watch_event.path.fnmatch?(glob)
+                  logger.trace("Received event(#{watch_event})")
                   @rule_engine_callback&.triggered(@trigger, { "event" => watch_event })
                 else
                   logger.trace("Event #{watch_event} did not match glob(#{glob})")

data/lib/openhab/dsl/rules.rb

@@ -1,29 +1,8 @@
 # frozen_string_literal: true
 
-require_relative "script_handling"
-
 module OpenHAB
   module DSL
     module Rules
-      @script_rules = {}
-
-      @scripted_rule_provider = OSGi.service(
-        "org.openhab.core.automation.module.script.rulesupport.shared.ScriptedRuleProvider"
-      )
-      class << self
-        # @!visibility private
-        attr_reader :script_rules, :scripted_rule_provider
-
-        #
-        # Cleanup rules in this script file
-        #
-        # @return [void]
-        #
-        def cleanup_rules
-          script_rules.each_value(&:cleanup)
-        end
-      end
-      Core::ScriptHandling.script_unloaded { cleanup_rules }
     end
   end
 end

data/lib/openhab/dsl/thread_local.rb

@@ -11,12 +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

@@ -185,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.rc2"
+    VERSION = "5.0.0.rc3"
   end
 end

data/lib/openhab/dsl.rb

@@ -41,80 +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)
-      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
-        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
+    # (see Rules::Builder#script)
+    def script(name = nil, id: nil, **kwargs, &block)
+      rules.build { script(name, id: id, **kwargs, &block) }
     end
 
     # @!group Rule Support
@@ -170,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
     #
@@ -296,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

data/lib/openhab/log.rb

@@ -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,9 +218,6 @@ 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"
@@ -411,6 +424,16 @@ module OpenHAB
           autoupdate_provider.add(metadata)
         end
       end
+
+      def restore_autoupdate_items
+        return unless instance_variable_defined?(:@autoupdated_items)
+
+        @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
 
     if defined?(::RSpec)

data/lib/openhab/rspec/hooks.rb

@@ -38,12 +38,12 @@ 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|
@@ -53,7 +53,7 @@ module OpenHAB
 
         config.before do |example|
           # clear persisted thing status
-          tm = OSGi.service("org.openhab.core.thing.ThingManager")
+          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
 
@@ -70,10 +70,6 @@ module OpenHAB
         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
           Core::Items::Proxy.reset_cache
           Core::Things::Proxy.reset_cache
           @profile_factory_registration.unregister
@@ -82,6 +78,7 @@ module OpenHAB
           # wipe this
           DSL::Items::TimedCommand.timed_commands.clear
           Timecop.return
+          restore_autoupdate_items
           Mocks::PersistenceService.instance.reset
         end
       end