openhab-scripting 4.18.0 → 4.21.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 775d56e757a494c9b854b963f2c15393c2521597cd83e5d36452a41033508339
-  data.tar.gz: 9dfd101285ad28b310156016e524a370352b192147f3fbf87d130135b5a48b9d
+  metadata.gz: 330baeb4ed7472cdf6c60ba060d0b4482f988fa72c8ff0dd33b00c3e2df28b4a
+  data.tar.gz: 35cab5382ecb542fcc90f02200c8ac977ccf4c1c880e2b644df2715c11fc36b1
 SHA512:
-  metadata.gz: 773d6bc398e5b24a9aecfb265c6025c75c4863ddf80932e875e9cb60eea4e6fdbf8036803d17c25dfd429127fc5164f1264b4bc48f7fce2cee1cd3fde837372a
-  data.tar.gz: 2e19d2dd05b40da151bd85a253e022209c93819acd20872bd1a30f02d9ad96cdb931c81499f7c222c2c487f962cb56f9db851dee6e3c038a671bac4d44f5481d
+  metadata.gz: a8c14ed23a21431328a55326313c06d16fdd0447426e741270d2f26ada96dee1425fb8e30da96b6d515b6c1406392ec56c2d3e598f5822b0a528273bacbbf441
+  data.tar.gz: 265d8939f4c02ccd883c006903d759c8f5208c6c80035a831344055c44c94880e703f76830ecd535464a8cbddd0d4e543cf5af23e35f379b3c532c9525cc9f2f

data/lib/openhab/core/openhab_setup.rb

@@ -18,14 +18,14 @@ module OpenHAB
     #
     #
     def self.wait_till_openhab_ready
-      logger.debug('Checking readyness of OpenHAB')
+      logger.trace('Checking readyness of OpenHAB')
       # rubocop: disable Style/GlobalVars
       until $scriptExtension.get('automationManager')
-        logger.debug("Automation manager not loaded, checking again in #{CHECK_DELAY} seconds.")
+        logger.trace("Automation manager not loaded, checking again in #{CHECK_DELAY} seconds.")
         sleep CHECK_DELAY
       end
       # rubocop: enable Style/GlobalVars
-      logger.debug 'Automation manager instantiated, OpenHAB ready for rule processing.'
+      logger.trace 'Automation manager instantiated, OpenHAB ready for rule processing.'
     end
   end
 end

data/lib/openhab/core/thread_local.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'openhab/log/logger'
+
 # OpenHAB main module
 module OpenHAB
   module Core
@@ -7,15 +9,18 @@ module OpenHAB
     # Manages thread local varaibles for access inside of blocks
     #
     module ThreadLocal
+      include OpenHAB::Log
+
       #
       # Execute the supplied block with the supplied values set for the currently running thread
       # The previous values for each key are restored after the block is executed
       #
-      # @param [Hash] Keys and values to set for running thread
+      # @param [Hash] Keys and values to set for running thread, if hash is nil no values are set
       #
       def thread_local(**values)
         old_values = values.map { |key, _value| [key, Thread.current[key]] }.to_h
         values.each { |key, value| Thread.current[key] = value }
+        logger.trace "Executing block with thread local context: #{values} - old context: #{old_values}"
         yield
       ensure
         old_values.each { |key, value| Thread.current[key] = value }

data/lib/openhab/dsl/dsl.rb

@@ -19,6 +19,7 @@ require 'openhab/dsl/things'
 require 'openhab/dsl/between'
 require 'openhab/dsl/gems'
 require 'openhab/dsl/persistence'
+require 'openhab/dsl/uid'
 require 'openhab/dsl/units'
 require 'openhab/dsl/states'
 

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

@@ -33,7 +33,7 @@ module OpenHAB
         #
         #
         def update_from_url(uri)
-          logger.debug("Downloading image from #{uri}")
+          logger.trace("Downloading image from #{uri}")
           response = Net::HTTP.get_response(URI(uri))
           mime_type = response['content-type']
           bytes = response.body

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

@@ -2,6 +2,7 @@
 
 require 'openhab/dsl/timers'
 require 'openhab/dsl/rules/triggers/trigger'
+require 'openhab/log/logger'
 require 'java'
 
 require_relative 'generic_item'
@@ -140,11 +141,15 @@ module OpenHAB
           #
           class TimedCommandCancelRule < Java::OrgOpenhabCoreAutomationModuleScriptRulesupportSharedSimple::SimpleRule
             include OpenHAB::Log
+            include OpenHAB::Core::ThreadLocal
+
             def initialize(timed_command_details, semaphore, &block)
               super()
               @semaphore = semaphore
               @timed_command_details = timed_command_details
               @block = block
+              # Capture rule name if known
+              @thread_locals = Thread.current[:RULE_NAME] ? { RULE_NAME: Thread.current[:RULE_NAME] } : {}
               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,
@@ -164,17 +169,19 @@ module OpenHAB
             # 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)
+                thread_local(@thread_locals) 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
             end

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

@@ -57,17 +57,19 @@ module OpenHAB
         # @param [Map] inputs map provided by OpenHAB rules engine containing event and other information
         #
         #
-        def execute(mod = nil, inputs = nil)
-          logger.trace { "Execute called with mod (#{mod&.to_string}) and inputs (#{inputs&.pretty_inspect})" }
-          logger.trace { "Event details #{inputs['event'].pretty_inspect}" } if inputs&.key?('event')
-          if trigger_delay inputs
-            trigger_delay = trigger_delay(inputs)
-            process_trigger_delay(trigger_delay, mod, inputs)
-          else
-            # If guards are satisfied execute the run type blocks
-            # If they are not satisfied, execute the Othewise blocks
-            queue = create_queue(inputs)
-            process_queue(queue, mod, inputs)
+        def execute(mod = nil, inputs = nil) # rubocop:disable Metrics/MethodLength
+          thread_local(RULE_NAME: name) do
+            logger.trace { "Execute called with mod (#{mod&.to_string}) and inputs (#{inputs&.pretty_inspect})" }
+            logger.trace { "Event details #{inputs['event'].pretty_inspect}" } if inputs&.key?('event')
+            if trigger_delay inputs
+              trigger_delay = trigger_delay(inputs)
+              process_trigger_delay(trigger_delay, mod, inputs)
+            else
+              # If guards are satisfied execute the run type blocks
+              # If they are not satisfied, execute the Othewise blocks
+              queue = create_queue(inputs)
+              process_queue(queue, mod, inputs)
+            end
           end
         end
 
@@ -336,10 +338,12 @@ module OpenHAB
         # @param [Task] task task containing otherwise block to execute
         #
         def process_task(event, task)
-          case task
-          when RuleConfig::Run then process_run_task(event, task)
-          when RuleConfig::Trigger then process_trigger_task(event, task)
-          when RuleConfig::Otherwise then process_otherwise_task(event, task)
+          thread_local(RULE_NAME: name) do
+            case task
+            when RuleConfig::Run then process_run_task(event, task)
+            when RuleConfig::Trigger then process_trigger_task(event, task)
+            when RuleConfig::Otherwise then process_otherwise_task(event, task)
+            end
           end
         end
 

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

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require 'java'
+require 'openhab/log/logger'
+
+module OpenHAB
+  module DSL
+    #
+    # Creates and manages OpenHAB Rules
+    #
+    module Rules
+      #
+      # Specialized rule for cron triggers with attachments because OpenHAB does not provide trigger UID for cron rules
+      #
+      class CronTriggerRule < Java::OrgOpenhabCoreAutomationModuleScriptRulesupportSharedSimple::SimpleRule
+        include OpenHAB::Log
+
+        def initialize(rule_config:, rule:, trigger:)
+          super()
+          set_name("#{rule_config.name}-cron-#{trigger.id}")
+          set_triggers([trigger])
+          @rule = rule
+          @trigger = trigger
+          logger.trace("Created Cron Trigger Rule for #{@trigger}")
+        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
+        #
+        #
+        def execute(mod = nil, _inputs = nil)
+          logger.trace "Trigger #{@trigger} fired for base rule #{@rule.inspect}"
+          inputs = { 'module' => @trigger.id }
+          @rule.execute(mod, inputs)
+        end
+      end
+    end
+  end
+end

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

@@ -1,8 +1,11 @@
 # frozen_string_literal: true
 
-require 'openhab/dsl/rules/rule_config'
-require 'openhab/dsl/rules/automation_rule'
-require 'openhab/dsl/rules/guard'
+require 'openhab/core/thread_local'
+require 'openhab/log/logger'
+require_relative 'rule_config'
+require_relative 'automation_rule'
+require_relative 'cron_trigger_rule'
+require_relative 'guard'
 
 module OpenHAB
   #
@@ -13,6 +16,9 @@ module OpenHAB
     # Creates and manages OpenHAB Rules
     #
     module Rules
+      include OpenHAB::Core::ThreadLocal
+      include OpenHAB::Log
+
       @script_rules = []
 
       # rubocop: disable Style/GlobalVars
@@ -31,29 +37,22 @@ module OpenHAB
       # @yield [] Block executed in context of a RuleConfig
       #
       #
+      # rubocop: disable Metrics/MethodLength
       def rule(rule_name, &block)
-        @rule_name = rule_name
-        config = RuleConfig.new(rule_name, block.binding)
-        config.instance_exec(config, &block)
-        config.guard = Guard::Guard.new(only_if: config.only_if, not_if: config.not_if)
-        logger.trace { config.inspect }
-        process_rule_config(config)
+        thread_local(RULE_NAME: rule_name) do
+          @rule_name = rule_name
+          config = RuleConfig.new(rule_name, block.binding)
+          config.instance_exec(config, &block)
+          config.guard = Guard::Guard.new(only_if: config.only_if, not_if: config.not_if)
+          logger.trace { config.inspect }
+          process_rule_config(config)
+          nil # Must return something other than the rule object. See https://github.com/boc-tothefuture/openhab-jruby/issues/438
+        end
       rescue StandardError => e
+        puts "#{e.class}: #{e.message}"
         re_raise_with_backtrace(e)
       end
-
-      #
-      # Create a logger where name includes rule name if name is set
-      #
-      # @return [Log::Logger] Logger with name that appended with rule name if rule name is set
-      #
-      def logger
-        if @rule_name
-          Log.logger_for(@rule_name.chomp.gsub(/\s+/, '_'))
-        else
-          super
-        end
-      end
+      # rubocop: enable Metrics/MethodLength
 
       #
       # Cleanup rules in this script file
@@ -84,13 +83,44 @@ module OpenHAB
       def process_rule_config(config)
         return unless create_rule?(config)
 
+        cron_attach_triggers, other_triggers = partition_triggers(config)
+        logger.trace("Cron triggers: #{cron_attach_triggers} -  Other triggers: #{other_triggers}")
+        config.triggers = other_triggers
+
         rule = AutomationRule.new(config: config)
         Rules.script_rules << rule
         add_rule(rule)
+
+        process_cron_attach(cron_attach_triggers, config, rule)
+
         rule.execute(nil, { 'event' => Struct.new(:attachment).new(config.start_attachment) }) if config.on_start?
         rule
       end
 
+      #
+      # Add cron triggers with attachments to rules
+      # @param [Array] cron_attach_triggers cron type triggers with attachments
+      #
+      def process_cron_attach(cron_attach_triggers, config, rule)
+        cron_attach_triggers&.map { |trigger| CronTriggerRule.new(rule_config: config, rule: rule, trigger: trigger) }
+                            &.each { |trigger| add_rule(trigger) }
+      end
+
+      #
+      # Partitions triggers in a config, removing cron triggers with a corresponding attachment
+      # so they can be used with CronTriggerRules to support attachments
+      # @return [Array] Two element array the first element is cron triggers with attachments,
+      #   second element is other triggers
+      #
+      def partition_triggers(config)
+        config
+          .triggers
+          .partition do |trigger|
+          trigger.typeUID == OpenHAB::DSL::Rules::Triggers::Trigger::CRON &&
+            config.attachments.key?(trigger.id)
+        end
+      end
+
       #
       # Should a rule be created based on rule configuration
       #
@@ -104,7 +134,7 @@ module OpenHAB
         elsif !execution_blocks?(config)
           logger.warn "Rule '#{config.name}' has no execution blocks, not creating rule"
         elsif !config.enabled
-          logger.debug "Rule '#{config.name}' marked as disabled, not creating rule."
+          logger.trace "Rule '#{config.name}' marked as disabled, not creating rule."
         else
           return true
         end
@@ -140,6 +170,7 @@ module OpenHAB
       #
       #
       def add_rule(rule)
+        logger.trace("Adding rule: #{rule.inspect}")
         Rules.automation_manager.addRule(rule)
       end
     end

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

@@ -33,7 +33,7 @@ module OpenHAB
         extend OpenHAB::DSL
 
         # @return [Array] Of triggers
-        attr_reader :triggers
+        attr_accessor :triggers
 
         # @return [Array] Of trigger delays
         attr_reader :trigger_delays
@@ -88,9 +88,9 @@ module OpenHAB
           @trigger_delays = {}
           @attachments = {}
           @caller = caller_binding.eval 'self'
+          name(rule_name)
           enabled(true)
           on_start(false)
-          name(rule_name)
         end
 
         #
@@ -134,19 +134,6 @@ module OpenHAB
           @caller.instance_eval(&block)
         end
 
-        #
-        # Create a logger where name includes rule name if name is set
-        #
-        # @return [Log::Logger] Logger with name that appended with rule name if rule name is set
-        #
-        def logger
-          if name
-            Log.logger_for(name.chomp.gsub(/\s+/, '_'))
-          else
-            super
-          end
-        end
-
         #
         # Inspect the config object
         #

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

@@ -15,16 +15,19 @@ module OpenHAB
         #
         # Creates a channel trigger
         #
-        # @param [Array] channels array to create triggers for on form of 'binding_id:type_id:thing_id#channel_id'
+        # @param [String, Channel, ChannelUID, Array<String, Channel, ChannelUID>] channels
+        #   channels to create triggers for in form of 'binding_id:type_id:thing_id#channel_id'
         #   or 'channel_id' if thing is provided
-        # @param [thing] thing to create trigger for if not specified with the channel
-        # @param [String] triggered specific triggering condition to match for trigger
-        #
-        #
-        def channel(*channels, thing: nil, triggered: nil, attach: nil)
-          channels.flatten.each do |channel|
-            channel = [thing, channel].join(':') if thing
-            logger.trace("Creating channel trigger for channel(#{channel}), thing(#{thing}), trigger(#{triggered})")
+        # @param [String, Thing, ThingUID, Array<String, Thing, ThingUID>] thing
+        #   thing(s) to create trigger for if not specified with the channel
+        # @param [String, Array<String>] triggered specific triggering condition(s) to match for trigger
+        #
+        def channel(*channels, thing: nil, triggered: nil, attach: nil) # rubocop:disable Metrics/AbcSize
+          channels.flatten.product([thing].flatten).each do |(channel, t)|
+            channel = channel.uid if channel.is_a?(org.openhab.core.thing.Channel)
+            t = t.uid if t.is_a?(Thing)
+            channel = [t, channel].compact.join(':')
+            logger.trace("Creating channel trigger for channel(#{channel}), thing(#{t}), trigger(#{triggered})")
             [triggered].flatten.each do |trigger|
               create_channel_trigger(channel, trigger, attach)
             end
@@ -36,14 +39,13 @@ module OpenHAB
         #
         # Create a trigger for a channel
         #
-        # @param [Channel] channel to look for triggers
-        # @param [Trigger] trigger specific channel trigger to match
+        # @param [String] channel to look for triggers
+        # @param [String] trigger specific channel trigger to match
         #
         #
         def create_channel_trigger(channel, trigger, attach)
           config = { 'channelUID' => channel }
           config['event'] = trigger.to_s unless trigger.nil?
-          config['channelUID'] = channel
           logger.trace("Creating Change Trigger for #{config}")
           append_trigger(Trigger::CHANNEL_EVENT, config, attach: attach)
         end

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

@@ -68,13 +68,13 @@ module OpenHAB
         # @param [Object] at TimeOfDay or String representing TimeOfDay in which to execute rule
         #
         #
-        def every(value, at: nil)
+        def every(value, at: nil, attach: nil)
           cron_expression = case value
                             when Symbol then cron_from_symbol(value, at)
                             when Java::JavaTime::Duration then cron_from_duration(value, at)
                             else raise ArgumentExpression, 'Unknown interval'
                             end
-          cron(cron_expression)
+          cron(cron_expression, attach: attach)
         end
 
         #
@@ -82,8 +82,8 @@ module OpenHAB
         #
         # @param [String] expression OpenHAB style cron expression
         #
-        def cron(expression)
-          @triggers << Trigger.trigger(type: Trigger::CRON, config: { 'cronExpression' => expression })
+        def cron(expression, attach: nil)
+          append_trigger(Trigger::CRON, { 'cronExpression' => expression }, attach: attach)
         end
 
         private

data/lib/openhab/dsl/things.rb

@@ -14,7 +14,7 @@ module OpenHAB
     # Support for OpenHAB Things
     #
     module Things
-      java_import Java::OrgOpenhabCoreThing::ThingStatus
+      java_import org.openhab.core.thing.ThingStatus
       include OpenHAB::Log
 
       #

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

@@ -25,12 +25,12 @@ module OpenHAB
         # @param [Duration] duration Duration until timer should fire
         # @param [Block] block Block to execute when timer fires
         #
-        def initialize(duration:, id:, &block)
+        def initialize(duration:, id:, thread_locals: {}, &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)
+          super(duration: duration, thread_locals: thread_locals, &block)
           logger.trace("Created Reentrant Timer #{self} with reentrant Key #{@reentrant_id}")
         end
 

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

@@ -4,6 +4,7 @@ require 'java'
 require 'delegate'
 require 'forwardable'
 require 'openhab/log/logger'
+require 'openhab/core/thread_local'
 
 module OpenHAB
   module DSL
@@ -22,6 +23,7 @@ module OpenHAB
       # @since 2.0.0
       class Timer < SimpleDelegator
         include OpenHAB::Log
+        include OpenHAB::Core::ThreadLocal
         extend Forwardable
 
         def_delegator :@timer, :has_terminated, :terminated?
@@ -32,8 +34,10 @@ module OpenHAB
         # @param [Duration] duration Duration until timer should fire
         # @param [Block] block Block to execute when timer fires
         #
-        def initialize(duration:, &block)
+        # rubocop: disable Metrics/MethodLength
+        def initialize(duration:, thread_locals: {}, &block)
           @duration = duration
+          @thread_locals = thread_locals
 
           # 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
@@ -41,13 +45,14 @@ module OpenHAB
 
           semaphore.synchronize do
             @timer = ScriptExecution.createTimer(
-              ZonedDateTime.now.plus(@duration), timer_block(semaphore, &block)
+              ZonedDateTime.now.plus(to_duration(@duration)), timer_block(semaphore, &block)
             )
             @rule_timers = Thread.current[:rule_timers]
             super(@timer)
             Timers.timer_manager.add(self)
           end
         end
+        # rubocop: enable Metrics/MethodLength
 
         #
         # Reschedule timer
@@ -57,15 +62,13 @@ module OpenHAB
         # @return [Timer] Rescheduled timer instances
         #
         def reschedule(duration = nil)
-          unless duration.nil? || duration.is_a?(Java::JavaTimeTemporal::TemporalAmount)
-            raise ArgumentError, 'Supplied argument must be a duration'
-          end
-
           duration ||= @duration
+
           Timers.timer_manager.add(self)
-          @timer.reschedule(ZonedDateTime.now.plus(duration))
+          @timer.reschedule(ZonedDateTime.now.plus(to_duration(duration)))
         end
 
+        #
         # Cancel timer
         #
         # @return [Boolean] True if cancel was successful, false otherwise
@@ -88,10 +91,33 @@ module OpenHAB
           proc {
             semaphore.synchronize do
               Timers.timer_manager.delete(self)
-              yield(self)
+              thread_local(@thread_locals) do
+                yield(self)
+              end
             end
           }
         end
+
+        #
+        # Convert argument to a duration
+        #
+        # @params [Java::JavaTimeTemporal::TemporalAmount, #to_f, #to_i, nil] duration Duration
+        #
+        # @raise if duration cannot be used for a timer
+        #
+        # @return Argument converted to seconds if it responds to #to_f or #to_i, otherwise duration unchanged
+        #
+        def to_duration(duration)
+          if duration.nil? || duration.is_a?(Java::JavaTimeTemporal::TemporalAmount)
+            duration
+          elsif duration.respond_to?(:to_f)
+            duration.to_f.seconds
+          elsif duration.respond_to?(:to_i)
+            duration.to_i.seconds
+          else
+            raise ArgumentError, "Supplied argument '#{duration}' cannot be converted to a duration"
+          end
+        end
       end
     end
   end

data/lib/openhab/dsl/timers.rb

@@ -29,9 +29,12 @@ module OpenHAB
       # @return [Timer] Timer object
       #
       def after(duration, id: nil, &block)
-        return Timers.reentrant_timer(duration: duration, id: id, &block) if id
+        # Carry rule name to timer thread
+        thread_locals = { RULE_NAME: Thread.current[:RULE_NAME] } if Thread.current[:RULE_NAME]
+        thread_locals ||= {}
+        return Timers.reentrant_timer(duration: duration, thread_locals: thread_locals, id: id, &block) if id
 
-        Timer.new(duration: duration, &block)
+        Timer.new(duration: duration, thread_locals: thread_locals, &block)
       end
 
       #
@@ -55,7 +58,7 @@ module OpenHAB
       # @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)
+      def self.reentrant_timer(duration:, id:, thread_locals: nil, &block)
         timer = @timer_manager.reentrant_timer(id: id, &block)
         if timer
           logger.trace("Reentrant timer found - #{timer}")
@@ -63,7 +66,7 @@ module OpenHAB
         else
           logger.trace('No reentrant timer found, creating new timer')
         end
-        ReentrantTimer.new(duration: duration, id: id, &block)
+        ReentrantTimer.new(duration: duration, id: id, thread_locals: thread_locals, &block)
       end
     end
   end

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

@@ -41,6 +41,20 @@ module OpenHAB
           equals(other)
         end
 
+        #
+        # Case equality
+        #
+        # @return [Boolean] if the values are of the same Type
+        #                   or item state of the same type
+        #
+        def ===(other)
+          logger.trace("(#{self.class}) #{self} === #{other} (#{other.class})")
+          other = other.state if other.respond_to?(:state)
+          return false unless instance_of?(other.class)
+
+          eql?(other)
+        end
+
         #
         # Check equality, including type conversion
         #

data/lib/openhab/dsl/uid.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module OpenHAB
+  module DSL
+    java_import org.openhab.core.common.AbstractUID
+    java_import org.openhab.core.thing.ThingTypeUID
+
+    # Adds methods to core OpenHAB AbstractUID to make it more natural in Ruby
+    class AbstractUID
+      # implicit conversion to string
+      alias to_str to_s
+      # inspect result is just the string representation
+      alias inspect to_s
+
+      # compares if equal to `other`, including string conversion
+      # @return [true, false]
+      def ==(other)
+        return true if equals(other)
+
+        to_s == other
+      end
+    end
+
+    # Adds methods to core OpenHAB ThingUID to make it more natural in Ruby
+    class ThingUID
+      # Returns the id of the binding this thing belongs to
+      # @return [String]
+      def binding_id
+        get_segment(0)
+      end
+    end
+
+    # Adds methods to core OpenHAB ThingTypeUID to make it more natural in Ruby
+    class ThingTypeUID
+      # Returns the id of the binding this thing type belongs to
+      # @return [String]
+      def binding_id
+        get_segment(0)
+      end
+    end
+
+    # have to remove == from all descendant classes so that they'll inherit
+    # the new implementation
+    [org.openhab.core.items.MetadataKey,
+     org.openhab.core.thing.UID,
+     org.openhab.core.thing.ChannelUID,
+     org.openhab.core.thing.ChannelGroupUID,
+     org.openhab.core.thing.ThingUID,
+     org.openhab.core.thing.ThingTypeUID,
+     org.openhab.core.thing.type.ChannelTypeUID,
+     org.openhab.core.thing.type.ChannelGroupTypeUID].each do |klass|
+      klass.remove_method(:==)
+    end
+  end
+end

data/lib/openhab/log/logger.rb

@@ -127,6 +127,7 @@ module OpenHAB
       end
     end
 
+    # Logger caches
     @loggers = {}
 
     # Return a logger with the configured log prefix plus the calling scripts name
@@ -137,7 +138,7 @@ module OpenHAB
     # @return [Logger] for the current class
     #
     def logger
-      Log.logger(self.class)
+      Log.logger(self)
     end
 
     class << self
@@ -148,29 +149,51 @@ module OpenHAB
       #
       # @return [Logger] for the supplied name
       #
-      def logger(klass)
+      def logger(object)
+        # Cache logger instances for each object since construction
+        # of logger name requires lots of operations and logger
+        # names for some objects are specific to the class
+        logger_name = logger_name(object)
+        @loggers[logger_name] ||= Logger.new(logger_name)
+      end
+
+      private
+
+      # Construct the logger name from the supplied object
+      # @param [Object] object to construct logger name from
+      # @return name for logger based on object
+      def logger_name(object)
+        name = Configuration.log_prefix
+        name += rules_file || ''
+        name += rule_name  || ''
+        name += klass_name(object) || ''
+        name.tr_s(' ', '_').gsub('::', '.')
+      end
+
+      # Get the class name for the supplied object
+      # @param [Object] object to derive class name for
+      # @return [String] name of class for logging
+      def klass_name(object)
+        object.then(&:class)
+              .then { |klass| java_klass(klass) }
+              .then(&:name)
+              .then { |name| filter_base_classes(name) }
+              .then { |name| name&.prepend('.') }
+      end
+
+      # Get the appropriate java class for the supplied klass if the supplied
+      # class is a java class
+      # @param [Class] klass to inspect
+      # @return Class or Java class of supplied class
+      def java_klass(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] name to configure logger for
-      #
-      # @return [Logger] for the supplied classname
-      #
-      def logger_for(name)
-        configure_logger_for(name)
+        klass
       end
 
-      private
-
       #
       # Configure a logger for the supplied classname
       #
@@ -178,16 +201,33 @@ module OpenHAB
       #
       # @return [Logger] Logger for the supplied classname
       #
-      def configure_logger_for(name)
-        log_prefix = Configuration.log_prefix
-        log_prefix += if name
-                        ".#{name}"
-                      else
-                        ".#{log_caller}"
-                      end
-        Logger.new(log_prefix)
+      def rules_file
+        # Each rules file gets its own context
+        # Set it once as a class value so that threads not
+        # tied to a rules file pick up the rules file they
+        # were spawned from
+        @rules_file ||= log_caller&.downcase&.prepend('.')
       end
 
+      # Get the name of the rule from the thread context
+      def rule_name
+        Thread.current[:RULE_NAME]&.downcase&.prepend('.')
+      end
+
+      # Filter out the base classes of Object and Module from the log name
+      def filter_base_classes(klass_name)
+        return nil if %w[Object Module].include?(klass_name)
+
+        klass_name
+      end
+
+      #  "#{rule_name.downcase}.#{klass_name}"
+      #  if klass_name == 'Object'
+      #  "rules.#{rules_file_name.downcase}"
+      #  else
+      #  "rules.#{rules_file_name.downcase}.#{klass_name}"
+      #  end
+
       #
       # Figure out the log prefix
       #
@@ -199,7 +239,7 @@ module OpenHAB
                         .grep_v(/rubygems/)
                         .grep_v(%r{lib/ruby})
                         .first
-                        .yield_self { |caller| File.basename(caller, '.*') }
+                        .then { |caller| File.basename(caller, '.*') if caller }
       end
     end
 

data/lib/openhab/version.rb

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

data/lib/openhab.rb

@@ -20,23 +20,18 @@ module OpenHAB
   #
   #
   # Number of extensions and includes requires more lines
-  # rubocop: disable Metrics/MethodLength
   def self.extended(base)
     OpenHAB::Core.wait_till_openhab_ready
     base.extend Log
     base.extend OpenHAB::Core::ScriptHandling
     base.extend OpenHAB::Core::EntityLookup
     base.extend OpenHAB::DSL
-    base.extend OpenHAB::DSL::Between
 
     base.send :include, OpenHAB::Core::ScriptHandlingCallbacks
-    base.send :include, OpenHAB::DSL::Items
-    base.send :include, OpenHAB::DSL::Types
-    logger.info "OpenHAB JRuby Scripting Library Version #{OpenHAB::VERSION} Loaded"
+    logger.debug "OpenHAB JRuby Scripting Library Version #{OpenHAB::VERSION} Loaded"
 
     OpenHAB::Core.add_rubylib_to_load_path
   end
-  # rubocop: enable Metrics/MethodLength
 end
 
 # Extend caller with OpenHAB methods

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: openhab-scripting
 version: !ruby/object:Gem::Version
-  version: 4.18.0
+  version: 4.21.0
 platform: ruby
 authors:
 - Brian O'Connell
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2021-11-30 00:00:00.000000000 Z
+date: 2021-12-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -94,6 +94,7 @@ files:
 - lib/openhab/dsl/monkey_patch/ruby/string.rb
 - lib/openhab/dsl/persistence.rb
 - lib/openhab/dsl/rules/automation_rule.rb
+- lib/openhab/dsl/rules/cron_trigger_rule.rb
 - lib/openhab/dsl/rules/guard.rb
 - lib/openhab/dsl/rules/item_event.rb
 - lib/openhab/dsl/rules/property.rb
@@ -136,6 +137,7 @@ files:
 - lib/openhab/dsl/types/types.rb
 - lib/openhab/dsl/types/un_def_type.rb
 - lib/openhab/dsl/types/up_down_type.rb
+- lib/openhab/dsl/uid.rb
 - lib/openhab/dsl/units.rb
 - lib/openhab/log/configuration.rb
 - lib/openhab/log/logger.rb