openhab-scripting 4.30.3 → 4.32.0

data/lib/openhab/dsl/rules/triggers/{watch.rb → watch/watch_handler.rb}

@@ -14,32 +14,15 @@ module OpenHAB
         #
         # Module for watching directories/files
         #
-        module Watch
+        module WatchHandler
           include OpenHAB::Log
 
-          # Characters in an fnmatch compatible glob
-          GLOB_CHARS = ['**', '*', '?', '[', ']', '{', '}'].freeze
-
-          #
-          # Creates trigger types and trigger type factories for OpenHAB
-          #
-          def self.add_watch_handler
-            java_import org.openhab.core.automation.type.TriggerType
-            OpenHAB::Core.automation_manager.add_trigger_handler(
-              OpenHAB::DSL::Rules::Triggers::Watch::WATCH_TRIGGER_MODULE_ID,
-              OpenHAB::DSL::Rules::Triggers::Watch::WatchTriggerHandlerFactory.new
-            )
-
-            OpenHAB::Core.automation_manager.add_trigger_type(watch_trigger_type)
-            OpenHAB::Log.logger(self).trace('Added watch trigger handler')
-          end
-
           #
           # Creates trigger types and trigger type factories for OpenHAB
           #
           private_class_method def self.watch_trigger_type
             TriggerType.new(
-              OpenHAB::DSL::Rules::Triggers::Watch::WATCH_TRIGGER_MODULE_ID,
+              WATCH_TRIGGER_MODULE_ID,
               nil,
               'A path change event is detected',
               'Triggers when a path change event is detected',
@@ -163,44 +146,19 @@ module OpenHAB
               WatchTriggerHandler.new(trigger)
             end
           end
-        end
 
-        #
-        # Create a trigger to watch a path
-        #
-        # @param [String] path to watch
-        #
-        # @return [Trigger] Trigger object
-        #
-        def watch(path, glob: '*', for: %i[created deleted modified], attach: nil)
-          glob, path = glob_for_path(Pathname.new(path), glob)
-          types = [binding.local_variable_get(:for)].flatten
-          conf = { path: path.to_s, types: types.map(&:to_s), glob: glob.to_s }
-
-          logger.trace("Creating a watch trigger for path(#{path}) with glob(#{glob}) for types(#{types})")
-          append_trigger(OpenHAB::DSL::Rules::Triggers::Watch::WATCH_TRIGGER_MODULE_ID,
-                         conf,
-                         attach: attach)
-        end
-
-        private
+          #
+          # Creates trigger types and trigger type factories for OpenHAB
+          #
+          def self.add_watch_handler
+            java_import org.openhab.core.automation.type.TriggerType
+            OpenHAB::Core.automation_manager.add_trigger_handler(
+              WATCH_TRIGGER_MODULE_ID,
+              WatchTriggerHandlerFactory.new
+            )
 
-        #
-        # Automatically creates globs for supplied paths if necessary
-        # @param [Pathname] path to check
-        # @param [String] specified glob
-        #
-        # @return [Pathname,String] Pathname to watch and glob to match
-        def glob_for_path(path, glob)
-          # Checks if the supplied pathname last element contains a glob char
-          if OpenHAB::DSL::Rules::Triggers::Watch::GLOB_CHARS.any? { |char| path.basename.to_s.include? char }
-            # Splits the supplied pathname into a glob string and parent path
-            [path.basename.to_s, path.parent]
-          elsif path.file? || !path.exist?
-            # glob string matching end of Pathname and parent path
-            ["*/#{path.basename}", path.parent]
-          else
-            [glob, path]
+            OpenHAB::Core.automation_manager.add_trigger_type(watch_trigger_type)
+            OpenHAB::Log.logger(self).trace('Added watch trigger handler')
           end
         end
       end
@@ -208,4 +166,4 @@ module OpenHAB
   end
 end
 # Add the watch handler to OpenHAB
-OpenHAB::DSL::Rules::Triggers::Watch.add_watch_handler
+OpenHAB::DSL::Rules::Triggers::WatchHandler.add_watch_handler

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

@@ -80,7 +80,7 @@ module OpenHAB
         end
 
         # any method that exists on String gets forwarded to to_s
-        delegate (String.instance_methods - instance_methods) => :to_s
+        delegate (String.instance_methods - instance_methods + %w[=~ inspect]) => :to_s
       end
     end
   end

data/lib/openhab/log/logger.rb

@@ -61,6 +61,22 @@ module OpenHAB
         define_method("#{level}_enabled?") { @sl4fj_logger.send("is_#{level}_enabled") }
       end
 
+      #
+      # Logs a map of key(value) with an optional preamble at trace level
+      # @param [String] preamble to put at start of log message
+      # @param [Hash] key and values to log
+      def state(preamble = 'State:', **kwargs)
+        return unless trace_enabled?
+
+        states = kwargs.transform_keys(&:to_s)
+                       .transform_keys(&:capitalize)
+                       .transform_values { |v| v.nil? ? 'nil' : v }
+                       .map { |k, v| "#{k}(#{v})" }
+                       .join(' ')
+        trace "#{preamble} #{states}"
+      end
+      alias states state
+
       #
       # Cleans the backtrace of an error to remove internal calls. If logging is set
       # to debug or lower, the full backtrace is kept

data/lib/openhab/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: openhab-scripting
 version: !ruby/object:Gem::Version
-  version: 4.30.3
+  version: 4.32.0
 platform: ruby
 authors:
 - Brian O'Connell
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2022-01-20 00:00:00.000000000 Z
+date: 2022-01-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -102,17 +102,21 @@ files:
 - lib/openhab/dsl/rules/property.rb
 - lib/openhab/dsl/rules/rule.rb
 - lib/openhab/dsl/rules/rule_config.rb
+- lib/openhab/dsl/rules/rule_triggers.rb
 - lib/openhab/dsl/rules/terse.rb
 - lib/openhab/dsl/rules/triggers/changed.rb
 - lib/openhab/dsl/rules/triggers/channel.rb
 - lib/openhab/dsl/rules/triggers/command.rb
 - lib/openhab/dsl/rules/triggers/conditions/duration.rb
 - lib/openhab/dsl/rules/triggers/conditions/proc.rb
-- lib/openhab/dsl/rules/triggers/cron.rb
+- lib/openhab/dsl/rules/triggers/cron/cron.rb
+- lib/openhab/dsl/rules/triggers/cron/cron_handler.rb
 - lib/openhab/dsl/rules/triggers/generic.rb
 - lib/openhab/dsl/rules/triggers/trigger.rb
+- lib/openhab/dsl/rules/triggers/triggers.rb
 - lib/openhab/dsl/rules/triggers/updated.rb
-- lib/openhab/dsl/rules/triggers/watch.rb
+- lib/openhab/dsl/rules/triggers/watch/watch.rb
+- lib/openhab/dsl/rules/triggers/watch/watch_handler.rb
 - lib/openhab/dsl/states.rb
 - lib/openhab/dsl/things.rb
 - lib/openhab/dsl/time/month_day.rb

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

@@ -1,288 +0,0 @@
-# frozen_string_literal: true
-
-require 'java'
-
-module OpenHAB
-  module DSL
-    module Rules
-      #
-      # Cron type rules
-      #
-      module Triggers
-        #
-        # Returns a default map for cron expressions that fires every second
-        # This map is usually updated via merge by other methods to refine cron type triggers.
-        #
-        # @return [Hash] Map with symbols for :seconds, :minute, :hour, :dom, :month, :dow
-        #   configured to fire every second
-        #
-        def cron_expression_map
-          {
-            second: '*',
-            minute: '*',
-            hour: '*',
-            dom: '?',
-            month: '*',
-            dow: '?'
-          }
-        end
-
-        module_function :cron_expression_map
-
-        # @return [Hash] Map of days of the week from symbols to to OpenHAB cron strings
-        DAY_OF_WEEK_MAP = {
-          monday: 'MON',
-          tuesday: 'TUE',
-          wednesday: 'WED',
-          thursday: 'THU',
-          friday: 'FRI',
-          saturday: 'SAT',
-          sunday: 'SUN'
-        }.freeze
-
-        private_constant :DAY_OF_WEEK_MAP
-
-        # @return [Hash] Converts the DAY_OF_WEEK_MAP to map used by Cron Expression
-        DAY_OF_WEEK_EXPRESSION_MAP = DAY_OF_WEEK_MAP.transform_values { |v| cron_expression_map.merge(dow: v) }
-
-        private_constant :DAY_OF_WEEK_EXPRESSION_MAP
-
-        # @return [Hash] Create a set of cron expressions based on different time intervals
-        EXPRESSION_MAP = {
-          second: cron_expression_map,
-          minute: cron_expression_map.merge(second: '0'),
-          hour: cron_expression_map.merge(second: '0', minute: '0'),
-          day: cron_expression_map.merge(second: '0', minute: '0', hour: '0'),
-          week: cron_expression_map.merge(second: '0', minute: '0', hour: '0', dow: 'MON'),
-          month: cron_expression_map.merge(second: '0', minute: '0', hour: '0', dom: '1'),
-          year: cron_expression_map.merge(second: '0', minute: '0', hour: '0', dom: '1', month: '1')
-        }.merge(DAY_OF_WEEK_EXPRESSION_MAP)
-                         .freeze
-
-        private_constant :EXPRESSION_MAP
-
-        #
-        # Create a rule that executes at the specified interval
-        #
-        # @param [Object] value Symbol or Duration to execute this rule
-        # @param [Object] at TimeOfDay or String representing TimeOfDay in which to execute rule
-        #
-        #
-        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, attach: attach)
-        end
-
-        #
-        # Create a OpenHAB Cron trigger
-        #
-        # @param [String] expression OpenHAB style cron expression
-        #
-        def cron(expression, attach: nil)
-          append_trigger(Trigger::CRON, { 'cronExpression' => expression }, attach: attach)
-        end
-
-        private
-
-        #
-        # Create a cron map from a duration
-        #
-        # @param [java::time::Duration] duration
-        # @param [Object] at TimeOfDay or String representing time of day
-        #
-        # @return [Hash] map describing cron expression
-        #
-        def cron_from_duration(duration, at)
-          raise ArgumentError, '"at" cannot be used with duration' if at
-
-          map_to_cron(duration_to_map(duration))
-        end
-
-        #
-        # Create a cron map from a symbol
-        #
-        # @param [Symbol] symbol
-        # @param [Object] at TimeOfDay or String representing time of day
-        #
-        # @return [Hash] map describing cron expression created from symbol
-        #
-        def cron_from_symbol(symbol, at)
-          expression_map = EXPRESSION_MAP[symbol]
-          expression_map = at_condition(expression_map, at) if at
-          map_to_cron(expression_map)
-        end
-
-        #
-        # Map cron expression to to cron string
-        #
-        # @param [Map] map of cron expression
-        #
-        # @return [String] OpenHAB cron string
-        #
-        def map_to_cron(map)
-          %i[second minute hour dom month dow].map { |field| map.fetch(field) }.join(' ')
-        end
-
-        #
-        # Convert a Java Duration to a map for the map_to_cron method
-        #
-        # @param duration [Java::JavaTime::Duration] The duration object
-        #
-        # @return [Hash] a map suitable for map_to_cron
-        #
-        def duration_to_map(duration)
-          if duration.to_millis_part.zero? && duration.to_nanos_part.zero? && duration.to_days.zero?
-            %i[second minute hour].each do |unit|
-              to_unit_part = duration.public_send("to_#{unit}s_part")
-              next unless to_unit_part.positive?
-
-              to_unit = duration.public_send("to_#{unit}s")
-              break unless to_unit_part == to_unit
-
-              return EXPRESSION_MAP[unit].merge(unit => "*/#{to_unit}")
-            end
-          end
-          raise ArgumentError, "Cron Expression not supported for duration: #{duration}"
-        end
-
-        #
-        # If an at time is provided, parse that and merge the new fields into the expression.
-        #
-        # @param [<Type>] expression_map <description>
-        # @param [<Type>] at_time <description>
-        #
-        # @return [<Type>] <description>
-        #
-        def at_condition(expression_map, at_time)
-          if at_time
-            tod = at_time.is_a?(TimeOfDay::TimeOfDay) ? at_time : TimeOfDay::TimeOfDay.parse(at_time)
-            expression_map = expression_map.merge(hour: tod.hour, minute: tod.minute, second: tod.second)
-          end
-          expression_map
-        end
-
-        #
-        # Cron trigger that provides trigger ID
-        #
-        module Cron
-          include OpenHAB::Log
-
-          #
-          # Creates trigger types and trigger type factories for OpenHAB
-          #
-          def self.add_script_cron_handler
-            java_import org.openhab.core.automation.type.TriggerType
-            OpenHAB::Core.automation_manager.add_trigger_handler(
-              OpenHAB::DSL::Rules::Triggers::Cron::CRON_TRIGGER_MODULE_ID,
-              OpenHAB::DSL::Rules::Triggers::Cron::CronTriggerHandlerFactory.new
-            )
-
-            OpenHAB::Core.automation_manager.add_trigger_type(cron_trigger_type)
-            OpenHAB::Log.logger(self).trace('Added script cron trigger handler')
-          end
-
-          #
-          # Creates trigger types and trigger type factories for OpenHAB
-          #
-          private_class_method def self.cron_trigger_type
-            TriggerType.new(
-              OpenHAB::DSL::Rules::Triggers::Cron::CRON_TRIGGER_MODULE_ID,
-              nil,
-              'A specific instant occurs',
-              'Triggers when the specified instant occurs',
-              nil,
-              org.openhab.core.automation.Visibility::VISIBLE,
-              nil
-            )
-          end
-
-          # Trigger ID for Watch Triggers
-          CRON_TRIGGER_MODULE_ID = 'jsr223.jruby.CronTrigger'
-
-          # Cron Trigger Handler that provides trigger IDs
-          # Unfortunatly because the CronTriggerHandler in OpenHAB core is marked internal
-          # the entire thing must be recreated here
-          class CronTriggerHandler < org.openhab.core.automation.handler.BaseTriggerModuleHandler
-            include OpenHAB::Log
-            include org.openhab.core.scheduler.SchedulerRunnable
-            include org.openhab.core.automation.handler.TimeBasedTriggerHandler
-
-            # Provides access to protected fields
-            field_accessor :callback
-
-            # Creates a new CronTriggerHandler
-            # @param [Trigger] OpenHAB trigger associated with handler
-            #
-            def initialize(trigger)
-              @trigger = trigger
-              @scheduler = OpenHAB::Core::OSGI.service('org.openhab.core.scheduler.CronScheduler')
-              @expression = trigger.configuration.get('cronExpression')
-              super(trigger)
-            end
-
-            #
-            # Set the callback to execute when cron trigger fires
-            # @param [Object] callback to run
-            #
-            def setCallback(callback) # rubocop:disable Naming/MethodName
-              synchronized do
-                super(callback)
-                @scheduler.schedule(self, @expression)
-                logger.trace("Scheduled cron job '#{@expression}' for trigger '#{@trigger.id}'.")
-              end
-            end
-
-            #
-            # Get the temporal adjuster
-            # @return [CronAdjuster]
-            #
-            def getTemporalAdjuster # rubocop:disable Naming/MethodName
-              org.openhab.core.scheduler.CronAdjuster.new(expression)
-            end
-
-            #
-            # Execute the callback
-            #
-            def run
-              callback&.triggered(@trigger, { 'module' => @trigger.id })
-            end
-
-            #
-            # Displose of the handler
-            # cancel the cron scheduled task
-            #
-            def dispose
-              synchronized do
-                super
-                return unless @schedule
-
-                @schedule&.cancel(true)
-              end
-              logger.trace("cancelled job for trigger '#{@trigger.id}'.")
-            end
-          end
-
-          # Implements the ScriptedTriggerHandlerFactory interface to create a new Cron Trigger Handler
-          class CronTriggerHandlerFactory
-            include org.openhab.core.automation.module.script.rulesupport.shared.factories.ScriptedTriggerHandlerFactory
-
-            # Invoked by the OpenHAB core to get a trigger handler for the supllied trigger
-            # @param [Trigger] OpenHAB trigger
-            #
-            # @return [WatchTriggerHandler] trigger handler for supplied trigger
-            def get(trigger)
-              CronTriggerHandler.new(trigger)
-            end
-          end
-        end
-      end
-    end
-  end
-end
-
-# Add the cron handler to OpenHAB
-OpenHAB::DSL::Rules::Triggers::Cron.add_script_cron_handler