openhab-jrubyscripting 5.0.0.rc2 → 5.0.0.rc4

data/lib/openhab/core/rules/rule.rb

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+module OpenHAB
+  module Core
+    module Rules
+      # @interface
+      java_import org.openhab.core.automation.Rule
+
+      #
+      # A {Rule} is a chunk of code that can execute when certain conditions are
+      # met, enabling the core dynamic functionality of openHAB.
+      #
+      module Rule
+        #
+        # @!method visible?
+        #   Check if visibility == `VISIBLE`
+        #   @return [true,false]
+        #
+
+        #
+        # @!method hidden?
+        #   Check if visibility == `HIDDEN`
+        #   @return [true,false]
+        #
+
+        #
+        # @!method expert?
+        #   Check if visibility == `EXPERT`
+        #   @return [true,false]
+        #
+
+        #
+        # @!method initializing?
+        #   Check if rule status == `INITIALIZING`
+        #   @return [true,false]
+        #
+        #
+        # @!method idle?
+        #   Check if rule status == `IDLE`
+        #   @return [true,false]
+        #
+        #
+        # @!method running?
+        #   Check if rule status == `RUNNING`
+        #   @return [true,false]
+        #
+
+        Visibility.constants.each do |visibility|
+          class_eval <<~RUBY, __FILE__, __LINE__ + 1
+            def #{visibility.to_s.downcase}?           # def visibile?
+              visibility == Visibility::#{visibility}  #   visibility == Visibility::VISIBLE
+            end                                        # end
+          RUBY
+        end
+
+        RuleStatus.constants.each do |status|
+          next if status == :UNINITIALIZED
+
+          class_eval <<~RUBY, __FILE__, __LINE__ + 1
+            def #{status.to_s.downcase}?       # def initializing?
+              status == RuleStatus::#{status}  #   status == RuleStatus::INITIALIZING
+            end                                # end
+          RUBY
+        end
+
+        #
+        # Check if rule status == `UNINITIALIZED`
+        #
+        # @return [true,false]
+        #
+        def uninitialized?
+          s = status
+          s.nil? || s == RuleStatus::UNINITIALIZED
+        end
+
+        #
+        # Enable the Rule
+        #
+        # @param [true, false] enabled
+        # @return [void]
+        #
+        def enable(enabled: true)
+          Rules.manager.set_enabled(uid, enabled)
+        end
+
+        #
+        # Disable the Rule
+        #
+        # @return [void]
+        #
+        def disable
+          enable(enabled: false)
+        end
+
+        #
+        # Check if the rule's status detail == `DISABLED`
+        #
+        # @return [true, false]
+        #
+        def disabled?
+          info = status_info
+          info.nil? || info.status_detail == RuleStatusDetail::DISABLED
+        end
+
+        #
+        # @!attribute [r] status
+        # @return [RuleStatus nil]
+        #
+        def status
+          Rules.manager.get_status(uid)
+        end
+
+        #
+        # @!attribute [r] status_info
+        # @return [RuleStatusInfo, nil]
+        #
+        def status_info
+          Rules.manager.get_status_info(uid)
+        end
+
+        # @return [String]
+        def inspect
+          r = "#<OpenHAB::Core::Rules::Rule #{uid}"
+          r += " #{name.inspect}" if name
+          r += " #{visibility}" unless visible?
+          r += " #{status || "<detached>"}"
+          r += " (#{status_info.status_detail})" if status_info && status_info.status_detail != RuleStatusDetail::NONE
+          r += " tags=#{tags.to_a.inspect}" unless tags.empty?
+          r += " configuration=#{configuration.properties.to_h}" if configuration && !configuration.properties.empty?
+          "#{r}>"
+        end
+
+        # @return [String]
+        def to_s
+          uid
+        end
+
+        #
+        # Manually trigger the rule
+        #
+        # @param [Object, nil] event The event to pass to the rule's execution blocks.
+        # @return [void]
+        #
+        def trigger(event = nil)
+          Rules.manager.run_now(uid, false, { "event" => event })
+        end
+      end
+    end
+  end
+end

data/lib/openhab/core/rules.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module OpenHAB
+  module Core
+    #
+    # Contains the core {Rule} as well as related infrastructure.
+    #
+    module Rules
+      java_import org.openhab.core.automation.RuleStatus,
+                  org.openhab.core.automation.RuleStatusInfo,
+                  org.openhab.core.automation.RuleStatusDetail,
+                  org.openhab.core.automation.Visibility
+
+      class << self
+        #
+        # @!attribute [r] rule_manager
+        # @return [org.openhab.core.automation.RuleManager] The OpenHAB rule manager/engine
+        #
+        def manager
+          @manager ||= OSGi.service("org.openhab.core.automation.RuleManager")
+        end
+      end
+    end
+  end
+end

data/lib/openhab/core/script_handling.rb

@@ -29,9 +29,11 @@ module OpenHAB
       #   end
       #
       def script_loaded(&block)
-        Core::ScriptHandlingCallbacks.script_loaded_hooks << block
+        ScriptHandlingCallbacks.script_loaded_hooks << block
       end
 
+      #
+      # @!method script_unloaded(&block)
       #
       # Add a block of code to be executed when the script is unloaded.
       #
@@ -47,8 +49,10 @@ module OpenHAB
       #     logger.info 'Hi, this script has been unloaded'
       #   end
       #
-      def script_unloaded(&block)
-        Core::ScriptHandlingCallbacks.script_unloaded_hooks << block
+      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)
       end
     end
 
@@ -58,6 +62,13 @@ module OpenHAB
     # @!visibility private
     module ScriptHandlingCallbacks
       class << self
+        #
+        # Has the script completed loading?
+        #
+        # @!visibility private
+        # @return [true, false]
+        attr_accessor :script_loaded
+
         #
         # Return script_loaded_hooks
         #
@@ -74,6 +85,7 @@ module OpenHAB
           @script_unloaded_hooks ||= []
         end
       end
+      self.script_loaded = false
 
       #
       # Executed when OpenHAB unloads a script file
@@ -85,6 +97,22 @@ module OpenHAB
         rescue => e
           logger.error("Failed to call script_unloaded hook #{hook}: #{e}")
         end
+
+        return if ScriptHandlingCallbacks.script_loaded
+
+        # Make sure we terminate the main thread if it's still set up, in case
+        # it's timing out and that's why we're unloading.
+        #
+        # It would seem simpler to just record Thread.current when this file
+        # loads, but if the user is using the autorequire feature of the
+        # jrubyscripting addon, this file will load before the main script.
+        #
+        # Note that Thread.list only includes threads that have had Ruby
+        # execute in them, so we don't need to worry about accidentally killing
+        # a random Java thread.
+        #
+        main_thread = Thread.list.find { |t| t != Thread.current && t.name.include?("-safeCall-") }
+        main_thread&.raise(Interrupt.new)
       end
 
       #
@@ -97,6 +125,7 @@ module OpenHAB
         rescue => e
           logger.error("Failed to call script_loaded hook #{hook}: #{e}")
         end
+        ScriptHandlingCallbacks.script_loaded = true
       end
     end
   end

data/lib/openhab/core/timer.rb

@@ -35,7 +35,6 @@ module OpenHAB
       # @return [Object, nil]
       attr_accessor :id
 
-      # @!visibility private
       # @!visibility private
       attr_reader :block
 
@@ -84,6 +83,7 @@ module OpenHAB
       # @return [self]
       #
       def reschedule(time = nil)
+        Thread.current[:openhab_rescheduled_timer] = true if Thread.current[:openhab_rescheduled_timer] == self
         DSL.timers.add(self)
         @timer.reschedule(new_execution_time(time || @time))
         self
@@ -119,12 +119,10 @@ module OpenHAB
       # @return [void]
       #
       def execute
-        last_execution_time = execution_time
-        DSL::ThreadLocal.thread_local(**@thread_locals) do
-          @block.call(self)
-        end
-        # don't remove ourselves if we were rescheduled in the block
-        DSL.timers.delete(self) if execution_time == last_execution_time
+        Thread.current[:openhab_rescheduled_timer] = self
+        DSL::ThreadLocal.thread_local(**@thread_locals) { @block.call(self) }
+        DSL.timers.delete(self) unless Thread.current[:openhab_rescheduled_timer] == true
+        Thread.current[:openhab_rescheduled_timer] = nil
       end
 
       #

data/lib/openhab/core/types.rb

@@ -13,7 +13,7 @@ module OpenHAB
     # Types are the specific data types that commands and states are. They can be
     # sent to items, be the current state of an item, or be the `command`, `state`,
     # and `was` field of various
-    # {group::OpenHAB::DSL::Rules::Builder::Triggers triggers}.
+    # {group::OpenHAB::DSL::Rules::BuilderDSL::Triggers triggers}.
     # Some types have additional useful methods.
     #
     module Types

data/lib/openhab/core.rb

@@ -53,22 +53,6 @@ module OpenHAB
       def automation_manager
         $scriptExtension.get("automationManager")
       end
-
-      #
-      # @!attribute [r] rule_registry
-      # @return [org.openhab.core.automation.RuleRegistry] The OpenHAB rule registry
-      #
-      def rule_registry
-        $scriptExtension.get("ruleRegistry")
-      end
-
-      #
-      # @!attribute [r] rule_manager
-      # @return [org.openhab.core.automation.RuleManager] The OpenHAB rule manager/engine
-      #
-      def rule_manager
-        @rule_manager ||= OSGi.service("org.openhab.core.automation.RuleManager")
-      end
     end
   end
 end