openhab-scripting 4.6.2 → 4.8.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 287e243222ea07f7a3157b208722d47f489f14456713ad86401292f6b2fda942
-  data.tar.gz: 44968c29cf24415646ebb27ce64c3894966c4e9f9707edcd303eb89d4a4b1f04
+  metadata.gz: 4d0594ce30afe7ee9653b705d23d24bc48489f7c0d264a0dd246d59d4266dc82
+  data.tar.gz: 2bec61de8afbaf4bbe180f510f6b797a9ab59449c506fc41f374d485c128698c
 SHA512:
-  metadata.gz: 12ce91f43449208a374b04ab92171a93c4ab3b68f2fee8ce7f948f7bf21f2be4a8d967b8f5758be957f5ca36cac831ebcb5f184204d650ed50d1fb345b1c2f7a
-  data.tar.gz: d7da5a64ab6aef028308a998ea83a77da1d77d12cbccb24c34875f6e51a9c6360e204efd75287de4d4f1fbc17b9bcd722057da227821f519452945fb17fd1666
+  metadata.gz: 419fd04010222b680c6d8a3c6c5c78752add3a7d0912333e9623a20b4ffe83d8fcc5a3ec62c9df811e3fb794611e3d5bf8961776af9ee3d74c2239fd8c10160e
+  data.tar.gz: f4e06ae879aee439acc8c6103093edd871f06e9c9ed89fb04fa74e5550849ea7e897e2e26b12c776aa93a2eacc4d9f0c00f2c3039ca73351e857cabd105d8577

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/metadata.rb

@@ -25,6 +25,7 @@ module OpenHAB
           extend Forwardable
 
           def_delegator :@metadata, :value
+          def_delegator :__getobj__, :to_h, :to_hash
 
           def initialize(metadata: nil, key: nil, value: nil, config: nil)
             @metadata = metadata || Metadata.new(key || MetadataKey.new('', ''), value&.to_s, config)
@@ -68,6 +69,7 @@ module OpenHAB
           # @return [Java::Org::openhab::core::items::Metadata] the old metadata
           #
           def config=(config)
+            config = config.to_hash if config.respond_to?(:to_hash)
             raise ArgumentError, 'Configuration must be a hash' unless config.is_a? Hash
 
             metadata = Metadata.new(@metadata&.uID, @metadata&.value, config)
@@ -158,7 +160,7 @@ module OpenHAB
             meta_value, configuration = update_from_value(value)
 
             key = MetadataKey.new(namespace, @item_name)
-            metadata = Metadata.new(key, meta_value&.to_s, configuration)
+            metadata = Metadata.new(key, meta_value&.to_s, configuration.to_h)
             # registry.get can be omitted, but registry.update will log a warning for nonexistent metadata
             if NamespaceAccessor.registry.get(key)
               NamespaceAccessor.registry.update(metadata)

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
@@ -230,9 +229,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

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
 
       #
@@ -45,7 +50,7 @@ module OpenHAB
       #
       def logger
         if @rule_name
-          Log.logger(@rule_name.chomp.gsub(/\s+/, '_'))
+          Log.logger_for(@rule_name.chomp.gsub(/\s+/, '_'))
         else
           super
         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/rule_config.rb

@@ -127,7 +127,7 @@ module OpenHAB
         #
         def logger
           if name
-            Log.logger(name.chomp.gsub(/\s+/, '_'))
+            Log.logger_for(name.chomp.gsub(/\s+/, '_'))
           else
             super
           end

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

@@ -39,7 +39,7 @@ module OpenHAB
             else
               # Place in array and flatten to support multiple to elements or single or nil
               [to].flatten.each do |to_state|
-                create_changed_trigger(item, from, to_state)
+                [from].flatten.each { |from_state| create_changed_trigger(item, from_state, to_state) }
               end
             end
           end

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

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require 'java'
 require_relative 'percent_type'
 
 module OpenHAB
@@ -65,6 +66,10 @@ module OpenHAB
               end
             end
 
+            # Convert strings using java class
+            return value_of(args.first) if args.length == 1 && args.first.is_a?(String)
+
+            # use super constructor for empty args
             return super unless args.length == 3
 
             # convert from several numeric-like types to the exact types
@@ -73,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
@@ -145,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

@@ -137,31 +137,36 @@ module OpenHAB
     # @return [Logger] for the current class
     #
     def logger
-      Log.logger(self.class.name)
+      Log.logger(self.class)
     end
 
     class << self
       #
       # Injects a logger into the base class
       #
-      # @param [String] name of the logger
+      # @param [Class] class the logger is for
       #
       # @return [Logger] for the supplied name
       #
-      def logger(name)
-        name ||= self.class.name
+      def logger(klass)
+        if klass.respond_to?(:java_class) &&
+           klass.java_class &&
+           !klass.java_class.name.start_with?('org.jruby.Ruby')
+          klass = klass.java_class
+        end
+        name = klass.name
         @loggers[name] ||= Log.logger_for(name)
       end
 
       #
       # Configure a logger for the supplied class name
       #
-      # @param [String] classname to configure logger for
+      # @param [String] name to configure logger for
       #
       # @return [Logger] for the supplied classname
       #
-      def logger_for(classname)
-        configure_logger_for(classname)
+      def logger_for(name)
+        configure_logger_for(name)
       end
 
       private
@@ -173,10 +178,10 @@ module OpenHAB
       #
       # @return [Logger] Logger for the supplied classname
       #
-      def configure_logger_for(classname)
+      def configure_logger_for(name)
         log_prefix = Configuration.log_prefix
-        log_prefix += if classname
-                        ".#{classname}"
+        log_prefix += if name
+                        ".#{name}"
                       else
                         ".#{log_caller}"
                       end
@@ -207,7 +212,7 @@ module OpenHAB
     def self.included(base)
       class << base
         def logger
-          Log.logger(self.class.name)
+          Log.logger(self)
         end
       end
     end

data/lib/openhab/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: openhab-scripting
 version: !ruby/object:Gem::Version
-  version: 4.6.2
+  version: 4.8.1
 platform: ruby
 authors:
 - Brian O'Connell
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2021-10-24 00:00:00.000000000 Z
+date: 2021-10-30 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