openhab-scripting 4.20.0 → 4.21.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 48c997bfb2b0275d7c7666b905eb1599e020c9d434965d9093613540b77460b1
-  data.tar.gz: a81a610e16bb811762faf1e7317432a86e7c332d7356b1b2bea827d674f1442c
+  metadata.gz: 330baeb4ed7472cdf6c60ba060d0b4482f988fa72c8ff0dd33b00c3e2df28b4a
+  data.tar.gz: 35cab5382ecb542fcc90f02200c8ac977ccf4c1c880e2b644df2715c11fc36b1
 SHA512:
-  metadata.gz: ae48e5f3f7e607c81fd2343a094b88e1b6c2041dc398357401ede48a41f0259f60d7c100afc4e3bd3d5217f635cf0d31e77cf072fbbe2b3871bf4f2d85477d94
-  data.tar.gz: 2ad2e05fa15ebc3a6de85ed5de804935d7d48d3b3e6a442dce0846fb0ccf993d07c04d09bed6861d4eb0d1b247a4d20a2d045156f150c9e76105fa7f9a75c361
+  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/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,30 +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)
-        nil # Must return something other than the rule object. See https://github.com/boc-tothefuture/openhab-jruby/issues/438
+        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
@@ -85,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
       #
@@ -105,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
@@ -141,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/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/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
@@ -48,6 +52,7 @@ module OpenHAB
             Timers.timer_manager.add(self)
           end
         end
+        # rubocop: enable Metrics/MethodLength
 
         #
         # Reschedule timer
@@ -86,7 +91,9 @@ module OpenHAB
           proc {
             semaphore.synchronize do
               Timers.timer_manager.delete(self)
-              yield(self)
+              thread_local(@thread_locals) do
+                yield(self)
+              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/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.20.0'
+  VERSION = '4.21.0'
 end

data/lib/openhab.rb

@@ -28,7 +28,7 @@ module OpenHAB
     base.extend OpenHAB::DSL
 
     base.send :include, OpenHAB::Core::ScriptHandlingCallbacks
-    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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: openhab-scripting
 version: !ruby/object:Gem::Version
-  version: 4.20.0
+  version: 4.21.0
 platform: ruby
 authors:
 - Brian O'Connell
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2021-12-01 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