openhab-scripting 4.30.3 → 4.30.4

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: openhab-scripting
 version: !ruby/object:Gem::Version
-  version: 4.30.3
+  version: 4.30.4
 platform: ruby
 authors:
 - Brian O'Connell
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2022-01-20 00:00:00.000000000 Z
+date: 2022-01-21 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