openhab-scripting 4.7.1 → 4.8.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e5e39f0dd326751e6c61fcf44a85f6a9033c72fc6196f899d59305f7e77ff2cf
-  data.tar.gz: 207a22d5633a711bdc333d1fb94befa787a6fa63a1b1050607c9f7665e1149f7
+  metadata.gz: 6f20bdd4334857cc9d65e95a218f509f90dd6f5b68d7acf550671f942385a426
+  data.tar.gz: a0bcdfba1ab5328f14b52ca16d9e56555fef6f479626aab11f655229a0c4f81a
 SHA512:
-  metadata.gz: cc744a57eaad8487ffcc3bb31584bfd484ee27de0948c07a1ac47be5953e5ee2fda4a1a0713f49fda4c289ffb298908d32d69741ce83ee3c526f0bec7c5ae173
-  data.tar.gz: 42a1fa4aa68bc0d81399f02de37761598005bed645b105f85f14af6d3419578938a3cbd33cd8a6c03b0fed46031c25730dca23074063d98ba76cc0eea43ccf24
+  metadata.gz: dd22e0e28fce41231eb34a2e0ed4c567b2457584f40852f9af7d684de6d981094bb8da5771b616191827fb42817e32cda3796b97aba8730de38fb95a80bb51b3
+  data.tar.gz: 00aeb56148a1c1117724515596a6ccdf8112246de26418b0ab0e978b75f2efc7766e545458e663a66f196d391c5eb9a281432d9aba6b5ef9b49250e1eae3702e

data/lib/openhab/dsl/items/image_item.rb

@@ -21,7 +21,7 @@ module OpenHAB
         #
         #
         def update_from_file(file, mime_type: nil)
-          file_data = IO.binread(file)
+          file_data = File.binread(file)
           mime_type ||= Marcel::MimeType.for(Pathname.new(file)) || Marcel::MimeType.for(file_data)
           update_from_bytes(file_data, mime_type: mime_type)
         end

data/lib/openhab/dsl/items/items.rb

@@ -22,6 +22,7 @@ require_relative 'rollershutter_item'
 require_relative 'string_item'
 
 require_relative 'ensure'
+require_relative 'timed_command'
 
 module OpenHAB
   module DSL
@@ -65,9 +66,9 @@ module OpenHAB
 
             logger.trace("Defining #{klass}##{command} for #{value}")
             klass.class_eval <<~RUBY, __FILE__, __LINE__ + 1
-              def #{command}       # def on
-                command(#{value})  #   command(ON)
-              end                  # end
+              def #{command}(for: nil, on_expire: nil, &block)                                          # def on(for: nil, on_expire: nil, &block )
+                command(#{value}, for: binding.local_variable_get(:for), on_expire: on_expire, &block)  #   command(ON, for: nil, expire: nil, &block)
+              end                                                                                       # end
             RUBY
 
             logger.trace("Defining GroupItem::GroupMembers##{command} for #{value}")

data/lib/openhab/dsl/items/timed_command.rb

@@ -0,0 +1,189 @@
+# frozen_string_literal: true
+
+require 'openhab/dsl/timers'
+require 'openhab/dsl/rules/triggers/trigger'
+require 'java'
+
+require_relative 'generic_item'
+
+module OpenHAB
+  module DSL
+    module Items
+      # Module enables timed commands e.g. Switch.on for: 3.minutes
+      module TimedCommand
+        # Stores information about timed commands
+        TimedCommandDetails = Struct.new(:item, :command, :was, :duration, :on_expire, :timer, :expired, :cancel_rule,
+                                         :rule_uid, keyword_init: true) do
+          def expired?
+            expired
+          end
+
+          def canceled?
+            !expired?
+          end
+        end
+
+        @timed_commands = {}
+
+        class << self
+          attr_reader :timed_commands
+        end
+
+        # Extensions for {Items::GenericItem} to implement timed commands
+        module GenericItem
+          #
+          #  Sends command to an item for specified duration, then on timer expiration sends
+          #  the expiration command to the item
+          #
+          # @param [Types::Type] command to send to object
+          # @param [Duration] for duration for item to be in command state
+          # @param [Types::Type] on_expire Command to send when duration expires
+          #
+          #
+          # rubocop: disable Metrics/MethodLength
+          # The mutex makes this over 10 lines, but there is usable way to break thsi method up
+          def command(command, for: nil, on_expire: nil, &block)
+            duration = binding.local_variable_get(:for)
+            return super(command) unless duration
+
+            # Timer needs access to rule to disable, rule needs access to timer to cancel.
+            # Using a mutux to ensure neither fires before the other is constructed
+            semaphore = Mutex.new
+
+            semaphore.synchronize do
+              timed_command_details = TimedCommand.timed_commands[self]
+              if timed_command_details.nil?
+                create_timed_command(command: command, duration: duration,
+                                     semaphore: semaphore, on_expire: on_expire, &block)
+              else
+                logger.trace "Outstanding Timed Command #{timed_command_details} encountered - rescheduling"
+                timed_command_details.duration = duration # Capture updated duration
+                timed_command_details.timer.reschedule duration
+              end
+            end
+
+            self
+          end
+          # rubocop: enable Metrics/MethodLength
+          alias << command
+
+          private
+
+          # Creates a new timed command and places it in the TimedCommand hash
+          # rubocop: disable Metrics/AbcSize
+          # rubocop: disable Metrics/MethodLength
+          # There is no feasible way to break this method into smaller components
+          def create_timed_command(command:, duration:, semaphore:, on_expire:, &block)
+            on_expire ||= default_on_expire(command)
+            timed_command_details = TimedCommandDetails.new(item: self, command: command, was: state,
+                                                            on_expire: on_expire, duration: duration)
+
+            # Send specified command after capturing current state
+            command(command)
+
+            timed_command_details.timer = timed_command_timer(timed_command_details, semaphore, &block)
+            timed_command_details.cancel_rule = TimedCommandCancelRule.new(timed_command_details, semaphore,
+                                                                           &block)
+            timed_command_details.rule_uid = OpenHAB::DSL::Rules.automation_manager
+                                                                .addRule(timed_command_details.cancel_rule).getUID
+            logger.trace "Created Timed Command #{timed_command_details}"
+            TimedCommand.timed_commands[self] = timed_command_details
+          end
+          # rubocop: enable Metrics/AbcSize
+          # rubocop: enable Metrics/MethodLength
+
+          # Creates the timer to handle changing the item state when timer expires or invoking user supplied block
+          # @param [TimedCommandDetailes] timed_command_details details about the timed command
+          # @param [Mutex] semaphore Semaphore to lock on to prevent race condition between rule and timer
+          # @return [Timer] Timer
+          # rubocop: disable Metrics/MethodLength
+          # There is no feasible way to break this method into smaller components
+          def timed_command_timer(timed_command_details, semaphore, &block)
+            after(timed_command_details.duration, id: self) do
+              semaphore.synchronize do
+                logger.trace "Timed command expired - #{timed_command_details}"
+                cancel_timed_command_rule(timed_command_details)
+                timed_command_details.expired = true
+                if block
+                  logger.trace "Invoking block #{block} after timed command for #{id} expired"
+                  yield(timed_command_details)
+                else
+                  command(timed_command_details.on_expire)
+                end
+
+                TimedCommand.timed_commands.delete(timed_command_details.item)
+              end
+            end
+          end
+          # rubocop: enable Metrics/MethodLength
+
+          # Cancels timed command rule
+          # @param [TimedCommandDetailed] timed_command details about the timed command
+          def cancel_timed_command_rule(timed_command_details)
+            logger.trace "Removing rule: #{timed_command_details.rule_uid}"
+            OpenHAB::DSL::Rules.registry.remove(timed_command_details.rule_uid)
+          end
+
+          #
+          # The default expire for ON/OFF is their inverse
+          #
+          def default_on_expire(command)
+            case format_type_pre(command)
+            when ON then OFF
+            when OFF then ON
+            else state
+            end
+          end
+
+          #
+          # Rule to cancel timed commands
+          #
+          class TimedCommandCancelRule < Java::OrgOpenhabCoreAutomationModuleScriptRulesupportSharedSimple::SimpleRule
+            include OpenHAB::Log
+            def initialize(timed_command_details, semaphore, &block)
+              super()
+              @semaphore = semaphore
+              @timed_command_details = timed_command_details
+              @block = block
+              set_name("Cancels implicit timer for #{timed_command_details.item.id}")
+              set_triggers([OpenHAB::DSL::Rules::Triggers::Trigger.trigger(
+                type: OpenHAB::DSL::Rules::Triggers::Trigger::ITEM_STATE_UPDATE,
+                config: { 'itemName' => timed_command_details.item.name }
+              )])
+            end
+
+            #
+            # Execute the rule
+            #
+            # @param [Map] mod map provided by OpenHAB rules engine
+            # @param [Map] inputs map provided by OpenHAB rules engine containing event and other information
+            #
+            #
+            # rubocop: disable Metrics/MethodLength
+            # rubocop: disable Metrics/AbcSize
+            # There is no feasible way to break this method into smaller components
+            def execute(_mod = nil, inputs = nil)
+              @semaphore.synchronize do
+                logger.trace "Canceling implicit timer #{@timed_command_details.timer} for "\
+                             "#{@timed_command_details.item.id}  because received event #{inputs}"
+                @timed_command_details.timer.cancel
+                # rubocop: disable Style/GlobalVars
+                # Disabled due to OpenHAB design
+                $scriptExtension.get('ruleRegistry').remove(@timed_command_details.rule_uid)
+                # rubocop: enable Style/GlobalVars
+                TimedCommand.timed_commands.delete(@timed_command_details.item)
+                if @block
+                  logger.trace 'Executing user supplied block on timed command cancelation'
+                  @block&.call(@timed_command_details)
+                end
+              end
+            end
+            # rubocop: enable Metrics/MethodLength
+            # rubocop: enable Metrics/AbcSize
+          end
+        end
+      end
+      GenericItem.prepend(TimedCommand::GenericItem)
+    end
+  end
+end

data/lib/openhab/dsl/rules/automation_rule.rb

@@ -68,8 +68,7 @@ module OpenHAB
         # Cleanup any resources associated with automation rule
         #
         def cleanup
-          logger.trace "Cancelling #{@trigger_delays.length} Trigger Delays(s) for rule '#{name}'"
-          @trigger_delays.each_value { |trigger_delay| trigger_delay.timer&.cancel }
+          # No cleanup is necessary right now, trigger delays are tracked and cancelled by timers library
         end
 
         private
@@ -78,7 +77,6 @@ module OpenHAB
         # Create the run queue based on guards
         #
         # @param [Map] inputs rule inputs
-        #
         # @return [Queue] <description>
         #
         def create_queue(inputs)
@@ -230,9 +228,9 @@ module OpenHAB
             logger.trace("Item changed to #{state} for #{trigger_delay}, rescheduling timer.")
             trigger_delay.timer.reschedule(ZonedDateTime.now.plus(trigger_delay.duration))
           else
-            logger.trace("Item changed to #{state} for #{trigger_delay}, cancelling timer.")
+            logger.trace("Item changed to #{state} for #{trigger_delay}, canceling timer.")
             trigger_delay.timer.cancel
-            # Reprocess trigger delay after cancelling to track new state (if guards matched, etc)
+            # Reprocess trigger delay after canceling to track new state (if guards matched, etc)
             process_trigger_delay(trigger_delay, mod, inputs)
           end
         end
@@ -244,6 +242,8 @@ module OpenHAB
         #
         # @return [Boolean] True if guards says rule should execute, false otherwise
         #
+        # rubocop:disable Metrics/MethodLength
+        # Loggging inflates method length
         def check_guards(event:)
           if @guard.should_run? event
             now = TimeOfDay::TimeOfDay.now
@@ -255,7 +255,10 @@ module OpenHAB
             logger.trace("Skipped execution of rule '#{name}' because of guard #{@guard}")
           end
           false
+        rescue StandardError => e
+          print_backtrace(e)
         end
+        # rubocop:enable Metrics/MethodLength
 
         #
         # Process the run queue

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

@@ -15,8 +15,13 @@ module OpenHAB
     module Rules
       @script_rules = []
 
+      # rubocop: disable Style/GlobalVars
+      @automation_manager = $scriptExtension.get('automationManager')
+      @registry = $scriptExtension.get('ruleRegistry')
+      # rubocop: enable Style/GlobalVars
+
       class << self
-        attr_reader :script_rules
+        attr_reader :script_rules, :automation_manager, :registry
       end
 
       #
@@ -134,9 +139,7 @@ module OpenHAB
       #
       #
       def add_rule(rule)
-        # rubocop: disable Style/GlobalVars
-        $scriptExtension.get('automationManager').addRule(rule)
-        # rubocop: enable Style/GlobalVars
+        Rules.automation_manager.addRule(rule)
       end
     end
   end

data/lib/openhab/dsl/rules/triggers/changed.rb

@@ -31,18 +31,18 @@ module OpenHAB
         # @return [Trigger] OpenHAB trigger
         #
         def changed(*items, to: nil, from: nil, for: nil)
-          separate_groups(items).each do |item|
+          separate_groups(items).map do |item|
             logger.trace("Creating changed trigger for entity(#{item}), to(#{to}), from(#{from})")
             # for is a reserved word in ruby, so use local_variable_get :for
             if (wait_duration = binding.local_variable_get(:for))
               changed_wait(item, to: to, from: from, duration: wait_duration)
             else
               # Place in array and flatten to support multiple to elements or single or nil
-              [to].flatten.each do |to_state|
-                [from].flatten.each { |from_state| create_changed_trigger(item, from_state, to_state) }
+              [to].flatten.map do |to_state|
+                [from].flatten.map { |from_state| create_changed_trigger(item, from_state, to_state) }
               end
             end
-          end
+          end.flatten
         end
 
         private
@@ -55,12 +55,13 @@ module OpenHAB
         # @param [Item State] to OpenHAB Item State item or group needs to change to
         # @param [Item State] from OpenHAB Item State item or group needs to be coming from
         #
-        # @return [Array] Array of current TriggerDelay objects
+        # @return [Trigger] OpenHAB trigger
         #
         def changed_wait(item, duration:, to: nil, from: nil)
           trigger = create_changed_trigger(item, nil, nil)
           logger.trace("Creating Changed Wait Change Trigger for #{item}")
           @trigger_delays[trigger.id] = TriggerDelay.new(to: to, from: from, duration: duration)
+          trigger
         end
 
         #

data/lib/openhab/dsl/rules/triggers/command.rb

@@ -22,14 +22,14 @@ module OpenHAB
         #
         #
         def received_command(*items, command: nil, commands: nil)
-          separate_groups(items).each do |item|
+          separate_groups(items).map do |item|
             logger.trace("Creating received command trigger for item(#{item})"\
                          "command(#{command}) commands(#{commands})")
 
             # Combine command and commands, doing union so only a single nil will be in the combined array.
             combined_commands = combine_commands(command, commands)
             create_received_trigger(combined_commands, item)
-          end
+          end.flatten
         end
 
         private
@@ -42,7 +42,7 @@ module OpenHAB
         #
         #
         def create_received_trigger(commands, item)
-          commands.each do |command|
+          commands.map do |command|
             if item.is_a? OpenHAB::DSL::Items::GroupItem::GroupMembers
               config, trigger = create_group_command_trigger(item)
             else

data/lib/openhab/dsl/rules/triggers/updated.rb

@@ -20,13 +20,13 @@ module OpenHAB
         # @return [Trigger] Trigger for updated entity
         #
         def updated(*items, to: nil)
-          separate_groups(items).each do |item|
+          separate_groups(items).map do |item|
             logger.trace("Creating updated trigger for item(#{item}) to(#{to})")
-            [to].flatten.each do |to_state|
+            [to].flatten.map do |to_state|
               trigger, config = create_update_trigger(item, to_state)
               append_trigger(trigger, config)
             end
-          end
+          end.flatten
         end
 
         private

data/lib/openhab/dsl/timers/manager.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+require 'openhab/log/logger'
+require_relative 'reentrant_timer'
+
+module OpenHAB
+  module DSL
+    #
+    # Provides access to and ruby wrappers around OpenHAB timers
+    #
+    module Timers
+      #
+      # Manages data structures that track timers
+      #
+      class TimerManager
+        include OpenHAB::Log
+
+        attr_reader :timer_ids
+
+        def initialize
+          # Track timer IDs
+          @timer_ids = Hash.new { |hash, key| hash[key] = Set.new }
+
+          # Reentrant timer lookups
+          @reentrant_timers = {}
+
+          # Tracks active timers
+          @timers = Set.new
+        end
+
+        #
+        # Adds the current timer to the set of rule timers if being tracked
+        #
+        # rubocop: disable Metrics/AbcSize
+        # It does not make sense to break this up into seperate components
+        def add(timer)
+          logger.trace("Adding #{timer} to timers")
+          @timers << timer
+
+          if timer.respond_to? :id
+            logger.trace("Adding #{timer} with id #{timer.id.inspect} timer ids")
+            @timer_ids[timer.id] << timer
+          end
+
+          return unless timer.respond_to? :reentrant_id
+
+          logger.trace("Adding reeentrant #{timer} with reentrant id #{timer.reentrant_id} timer ids")
+          @reentrant_timers[timer.reentrant_id] = timer
+        end
+        # rubocop: enable Metrics/AbcSize
+
+        # Fetches the reentrant timer that matches the supplied id and block if it exists
+        #
+        # @param [Object] Object to associate with timer
+        # @param [Block] block to execute, block is passed a Timer object
+        #
+        # @return [RentrantTimer] Timer object if it exists, nil otherwise
+        #
+        def reentrant_timer(id:, &block)
+          reentrant_key = ReentrantTimer.reentrant_id(id: id, &block)
+          logger.trace("Checking for existing reentrant timer for #{reentrant_key}")
+          @reentrant_timers[reentrant_key]
+        end
+
+        #
+        # Delete the current timer to the set of rule timers if being tracked
+        #
+        def delete(timer)
+          logger.trace("Removing #{timer} from timers")
+          @timers.delete(timer)
+          @timer_ids[timer.id].delete(timer) if (timer.respond_to? :id) && (@timer_ids.key? timer.id)
+          @reentrant_timers.delete(timer.reentrant_id) if timer.respond_to? :reentrant_id
+        end
+
+        #
+        # Cancels all active timers
+        #
+        def cancel_all
+          logger.trace("Canceling #{@timers.length} timers")
+          @timers.each(&:cancel)
+          @timer_ids.clear
+          @reentrant_timers.clear
+          @timers.clear
+        end
+      end
+    end
+  end
+end

data/lib/openhab/dsl/timers/reentrant_timer.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require 'openhab/log/logger'
+require_relative 'timer'
+
+module OpenHAB
+  module DSL
+    #
+    # Provides access to and ruby wrappers around OpenHAB timers
+    #
+    module Timers
+      # A reentrant timer is a timer that is automatically rescheduled
+      # when the block it refers to is encountered again
+      #
+      # @author Brian O'Connell
+      # @since 2.0.0
+      class ReentrantTimer < Timer
+        include OpenHAB::Log
+
+        attr_reader :id, :reentrant_id
+
+        #
+        # Create a new Timer Object
+        #
+        # @param [Duration] duration Duration until timer should fire
+        # @param [Block] block Block to execute when timer fires
+        #
+        def initialize(duration:, id:, &block)
+          raise 'Reentrant timers do not work in dynamically generated code' unless block.source_location
+
+          @id = id
+          @reentrant_id = self.class.reentrant_id(id: id, &block)
+          super(duration: duration, &block)
+          logger.trace("Created Reentrant Timer #{self} with reentrant Key #{@reentrant_id}")
+        end
+
+        def self.reentrant_id(id:, &block)
+          [id, block.source_location].flatten
+        end
+      end
+    end
+  end
+end

data/lib/openhab/dsl/timers/timer.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+require 'java'
+require 'delegate'
+require 'forwardable'
+require 'openhab/log/logger'
+
+module OpenHAB
+  module DSL
+    #
+    # Provides access to and ruby wrappers around OpenHAB timers
+    #
+    module Timers
+      include OpenHAB::Log
+      java_import org.openhab.core.model.script.actions.ScriptExecution
+      java_import java.time.ZonedDateTime
+
+      # Ruby wrapper for OpenHAB Timer
+      # This class implements delegator to delegate methods to the OpenHAB timer
+      #
+      # @author Brian O'Connell
+      # @since 2.0.0
+      class Timer < SimpleDelegator
+        include OpenHAB::Log
+        extend Forwardable
+
+        def_delegator :@timer, :is_active, :active?
+        def_delegator :@timer, :is_running, :running?
+        def_delegator :@timer, :has_terminated, :terminated?
+
+        #
+        # Create a new Timer Object
+        #
+        # @param [Duration] duration Duration until timer should fire
+        # @param [Block] block Block to execute when timer fires
+        #
+        def initialize(duration:, &block)
+          @duration = duration
+
+          # A semaphore is used to prevent a race condition in which calling the block from the timer thread
+          # occurs before the @timer variable can be set resulting in @timer being nil
+          semaphore = Mutex.new
+
+          semaphore.synchronize do
+            @timer = ScriptExecution.createTimer(
+              ZonedDateTime.now.plus(@duration), timer_block(semaphore, &block)
+            )
+            @rule_timers = Thread.current[:rule_timers]
+            super(@timer)
+            Timers.timer_manager.add(self)
+          end
+        end
+
+        #
+        # Reschedule timer
+        #
+        # @param [Duration] duration
+        #
+        # @return [Timer] Rescheduled timer instances
+        #
+        def reschedule(duration = nil)
+          duration ||= @duration
+          Timers.timer_manager.add(self)
+          @timer.reschedule(ZonedDateTime.now.plus(duration))
+        end
+
+        # Cancel timer
+        #
+        # @return [Boolean] True if cancel was successful, false otherwise
+        #
+        def cancel
+          Timers.timer_manager.delete(self)
+          @timer.cancel
+        end
+
+        private
+
+        #
+        # Constructs a block to execute timer within
+        #
+        # @param [Semaphore] Semaphore to obtain before executing
+        #
+        # @return [Proc] Block for timer to execute
+        #
+        def timer_block(semaphore)
+          proc {
+            semaphore.synchronize do
+              Timers.timer_manager.delete(self)
+              yield(self)
+            end
+          }
+        end
+      end
+    end
+  end
+end

data/lib/openhab/dsl/timers.rb

@@ -1,9 +1,8 @@
 # frozen_string_literal: true
 
-require 'java'
-require 'delegate'
-require 'forwardable'
-require 'openhab/log/logger'
+require_relative 'timers/timer'
+require_relative 'timers/manager'
+require_relative 'timers/reentrant_timer'
 
 module OpenHAB
   module DSL
@@ -12,109 +11,58 @@ module OpenHAB
     #
     module Timers
       include OpenHAB::Log
-      java_import org.openhab.core.model.script.actions.ScriptExecution
-      java_import java.time.ZonedDateTime
 
-      # Tracks active timers
-      @timers = Set.new
-      class << self
-        attr_accessor :timers
-      end
-
-      # Ruby wrapper for OpenHAB Timer
-      # This class implements delegator to delegate methods to the OpenHAB timer
-      #
-      # @author Brian O'Connell
-      # @since 2.0.0
-      class Timer < SimpleDelegator
-        include OpenHAB::Log
-        extend Forwardable
-
-        def_delegator :@timer, :is_active, :active?
-        def_delegator :@timer, :is_running, :running?
-        def_delegator :@timer, :has_terminated, :terminated?
-
-        #
-        # Create a new Timer Object
-        #
-        # @param [Duration] duration Duration until timer should fire
-        # @param [Block] block Block to execute when timer fires
-        #
-        def initialize(duration:, &block)
-          @duration = duration
-
-          # A semaphore is used to prevent a race condition in which calling the block from the timer thread
-          # occurs before the @timer variable can be set resulting in @timer being nil
-          semaphore = Mutex.new
-
-          semaphore.synchronize do
-            @timer = ScriptExecution.createTimer(
-              ZonedDateTime.now.plus(@duration), timer_block(semaphore, &block)
-            )
-            super(@timer)
-            Timers.timers << self
-          end
-        end
-
-        #
-        # Reschedule timer
-        #
-        # @param [Duration] duration
-        #
-        # @return [Timer] Rescheduled timer instances
-        #
-        def reschedule(duration = nil)
-          duration ||= @duration
-          Timers.timers << self
-          @timer.reschedule(ZonedDateTime.now.plus(duration))
-        end
-
-        # Cancel timer
-        #
-        # @return [Boolean] True if cancel was successful, false otherwise
-        #
-        def cancel
-          Timers.timers.delete(self)
-          @timer.cancel
-        end
+      # Manages timers
+      @timer_manager = TimerManager.new
 
-        private
-
-        #
-        # Constructs a block to execute timer within
-        #
-        # @param [Semaphore] Semaphore to obtain before executing
-        #
-        # @return [Proc] Block for timer to execute
-        #
-        def timer_block(semaphore)
-          proc {
-            semaphore.synchronize do
-              Timers.timers.delete(self)
-              yield(self)
-            end
-          }
-        end
+      class << self
+        attr_reader :timer_manager
       end
 
       #
       # Execute the supplied block after the specified duration
       #
       # @param [Duration] duration after which to execute the block
+      # @param [Object] id to associate with timer
       # @param [Block] block to execute, block is passed a Timer object
       #
       # @return [Timer] Timer object
       #
-      def after(duration, &block)
+      def after(duration, id: nil, &block)
+        return Timers.reentrant_timer(duration: duration, id: id, &block) if id
+
         Timer.new(duration: duration, &block)
       end
 
+      #
+      # Provdes access to the hash for mapping timer ids to the set of active timers associated with that id
+      # @return [Hash] hash of user specified ids to sets of times
+      def timers
+        Timers.timer_manager.timer_ids
+      end
+
       #
       # Cancels all active timers
       #
       def self.cancel_all
-        logger.trace("Cancelling #{@timers.length} timers")
-        @timers.each(&:cancel)
+        @timer_manager.cancel_all
+      end
+
+      # Create or reschedule a reentrant time
+      #
+      # @param [Duration] duration after which to execute the block
+      # @param [Object] id to associate with timer
+      # @param [Block] block to execute, block is passed a Timer object
+      # @return [ReentrantTimer] Timer object
+      def self.reentrant_timer(duration:, id:, &block)
+        timer = @timer_manager.reentrant_timer(id: id, &block)
+        if timer
+          logger.trace("Reentrant timer found - #{timer}")
+          timer.reschedule
+        else
+          logger.trace('No reentrant timer found, creating new timer')
+          ReentrantTimer.new(duration: duration, id: id, &block)
+        end
       end
     end
   end

data/lib/openhab/dsl/types/hsb_type.rb

@@ -78,7 +78,7 @@ module OpenHAB
             args[0] = if hue.is_a?(DecimalType)
                         hue
                       elsif hue.is_a?(QuantityType)
-                        DecimalType.new(hue.to_unit(::Units::DEGREE_ANGLE).to_big_decimal)
+                        DecimalType.new(hue.to_unit(org.openhab.core.library.unit.Units::DEGREE_ANGLE).to_big_decimal)
                       elsif hue.respond_to?(:to_d)
                         DecimalType.new(hue)
                       end
@@ -150,7 +150,7 @@ module OpenHAB
         # @!attribute [r] hue
         # @return [QuantityType]
         def hue
-          QuantityType.new(raw_hue.to_big_decimal, ::Units::DEGREE_ANGLE)
+          QuantityType.new(raw_hue.to_big_decimal, org.openhab.core.library.unit.Units::DEGREE_ANGLE)
         end
 
         # Convert to a packed 32-bit RGB value representing the color in the default sRGB color model.

data/lib/openhab/log/logger.rb

@@ -73,7 +73,7 @@ module OpenHAB
         return error if debug_enabled?
 
         if error.respond_to? :backtrace_locations
-          backtrace = error.backtrace_locations.map(&:to_s).reject { |line| INTERNAL_CALL_REGEX.match? line }
+          backtrace = error.backtrace_locations.map(&:to_s).grep_v(INTERNAL_CALL_REGEX)
           error.set_backtrace(backtrace)
         elsif error.respond_to? :stack_trace
           backtrace = error.stack_trace.reject { |line| JAVA_INTERNAL_CALL_REGEX.match? line.to_s }

data/lib/openhab/version.rb

@@ -5,5 +5,5 @@
 #
 module OpenHAB
   # @return [String] Version of OpenHAB helper libraries
-  VERSION = '4.7.1'
+  VERSION = '4.8.3'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: openhab-scripting
 version: !ruby/object:Gem::Version
-  version: 4.7.1
+  version: 4.8.3
 platform: ruby
 authors:
 - Brian O'Connell
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2021-10-29 00:00:00.000000000 Z
+date: 2021-10-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -77,6 +77,7 @@ files:
 - lib/openhab/dsl/items/rollershutter_item.rb
 - lib/openhab/dsl/items/string_item.rb
 - lib/openhab/dsl/items/switch_item.rb
+- lib/openhab/dsl/items/timed_command.rb
 - lib/openhab/dsl/lazy_array.rb
 - lib/openhab/dsl/monkey_patch/actions/actions.rb
 - lib/openhab/dsl/monkey_patch/actions/script_thing_actions.rb
@@ -106,6 +107,9 @@ files:
 - lib/openhab/dsl/things.rb
 - lib/openhab/dsl/time_of_day.rb
 - lib/openhab/dsl/timers.rb
+- lib/openhab/dsl/timers/manager.rb
+- lib/openhab/dsl/timers/reentrant_timer.rb
+- lib/openhab/dsl/timers/timer.rb
 - lib/openhab/dsl/types/comparable_type.rb
 - lib/openhab/dsl/types/date_time_type.rb
 - lib/openhab/dsl/types/decimal_type.rb