openhab-scripting 4.30.3 → 4.32.0

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

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+require 'java'
+require_relative 'cron'
+
+module OpenHAB
+  module DSL
+    module Rules
+      #
+      # Cron type rules
+      #
+      module Triggers
+        #
+        # Cron trigger handler that provides trigger ID
+        #
+        module CronHandler
+          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::CronHandler::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
+
+          # 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::CronHandler.add_script_cron_handler

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

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'openhab/log/logger'
+require_relative 'trigger'
 
 module OpenHAB
   module DSL
@@ -21,7 +22,7 @@ module OpenHAB
         #
         def trigger(type, attach: nil, **configuration)
           logger.trace("Creating a generic trigger for type(#{type}) with configuration(#{configuration})")
-          append_trigger(type, configuration, attach: attach)
+          Trigger.new(rule_triggers: @rule_triggers).append_trigger(type: type, config: configuration, attach: attach)
         end
       end
     end

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

@@ -1,8 +1,6 @@
 # frozen_string_literal: true
 
-require 'securerandom'
-require 'java'
-require_relative 'cron'
+require 'forwardable'
 
 module OpenHAB
   module DSL
@@ -11,132 +9,66 @@ module OpenHAB
       # Module holds rule triggers
       #
       module Triggers
-        #
-        # Create a trigger for a thing
-        #
-        # @param [Thing] thing to create trigger for
-        # @param [Trigger] trigger to map with thing
-        # @param [State] to for thing
-        # @param [State] from state of thing
-        #
-        # @return [Array] Trigger and config for thing
-        #
-        def trigger_for_thing(thing, trigger, to = nil, from = nil)
-          config = { 'thingUID' => thing.uid.to_s }
-          config['status'] = trigger_state_from_symbol(to).to_s if to
-          config['previousStatus'] = trigger_state_from_symbol(from).to_s if from
-          [trigger, config]
-        end
-
-        #
-        # converts object to upcase string if its a symbol
-        #
-        # @param [sym] sym potential symbol to convert
-        #
-        # @return [String] Upcased symbol as string
-        #
-        def trigger_state_from_symbol(sym)
-          sym.to_s.upcase if (sym.is_a? Symbol) || sym
-        end
-
-        #
-        # Append a trigger to the list of triggeres
-        #
-        # @param [String] type of trigger to create
-        # @param [Map] config map describing trigger configuration
-        #
-        # @return [Trigger] OpenHAB trigger
-        #
-        def append_trigger(type, config, attach: nil)
-          logger.trace("Creating trigger of type #{type} for #{config}")
-          config.transform_keys!(&:to_s)
-          trigger = Trigger.trigger(type: type, config: config)
-          @attachments[trigger.id] = attach if attach
-          @triggers << trigger
-          trigger
-        end
-
-        #
-        # Separates groups from items, and flattens any nested arrays of items
-        #
-        # @param [Array] item_array Array of items passed to a trigger
-        #
-        # @return [Array] A new flat array with any GroupMembers object left intact
-        #
-        def separate_groups(item_array)
-          # we want to support anything that can be flattened... i.e. responds to to_ary
-          # we want to be more lenient than only things that are currently Array,
-          # but Enumerable is too lenient because Array#flatten won't traverse interior
-          # Enumerables
-          return item_array unless item_array.find { |item| item.respond_to?(:to_ary) }
-
-          groups, items = item_array.partition { |item| item.is_a?(OpenHAB::DSL::Items::GroupItem::GroupMembers) }
-          groups + separate_groups(items.flatten(1))
-        end
-
         #
         # Class for creating and managing triggers
         #
         class Trigger
-          java_import org.openhab.core.automation.util.TriggerBuilder
-          java_import org.openhab.core.config.core.Configuration
-
-          # @return [String] A channel event trigger
-          CHANNEL_EVENT = 'core.ChannelEventTrigger'
-
-          # @return [String] A thing status Change trigger
-          THING_CHANGE = 'core.ThingStatusChangeTrigger'
-
-          # @return [String] A thing status update trigger
-          THING_UPDATE = 'core.ThingStatusUpdateTrigger'
-
-          # @return [String] An item command trigger
-          ITEM_COMMAND = 'core.ItemCommandTrigger'
-
-          # @return [String] An item state update trigger
-          ITEM_STATE_UPDATE = 'core.ItemStateUpdateTrigger'
-
-          # @return [String] An item state change trigger
-          ITEM_STATE_CHANGE = 'core.ItemStateChangeTrigger'
+          extend Forwardable
 
-          # @return [String] A group state change trigger for items in the group
-          GROUP_STATE_CHANGE = 'core.GroupStateChangeTrigger'
+          # Provide backwards compatibility for these fields
+          delegate :append_trigger => :@rule_triggers
 
-          # @return [String] A group state update trigger for items in the group
-          GROUP_STATE_UPDATE = 'core.GroupStateUpdateTrigger'
-
-          # @return [String] A group command trigger for items in the group
-          GROUP_COMMAND = 'core.GroupCommandTrigger'
-
-          # @return [String] A time of day trigger
-          TIME_OF_DAY = 'timer.TimeOfDayTrigger'
+          #
+          # Separates groups from items, and flattens any nested arrays of items
+          #
+          # @param [Array] item_array Array of items passed to a trigger
+          #
+          # @return [Array] A new flat array with any GroupMembers object left intact
+          #
+          def self.flatten_items(item_array)
+            # we want to support anything that can be flattened... i.e. responds to to_ary
+            # we want to be more lenient than only things that are currently Array,
+            # but Enumerable is too lenient because Array#flatten won't traverse interior
+            # Enumerables
+            return item_array unless item_array.find { |item| item.respond_to?(:to_ary) }
+
+            groups, items = item_array.partition { |item| item.is_a?(OpenHAB::DSL::Items::GroupItem::GroupMembers) }
+            groups + flatten_items(items.flatten(1))
+          end
 
-          # @return [String] A cron trigger
-          CRON = OpenHAB::DSL::Rules::Triggers::Cron::CRON_TRIGGER_MODULE_ID
+          #
+          # Creates a new Trigger
+          # @param [RuleTrigger] rule trigger information
+          def initialize(rule_triggers:)
+            @rule_triggers = rule_triggers
+          end
 
           #
-          # Create a trigger
+          # Create a trigger for a thing
           #
-          # @param [String] type of trigger
-          # @param [Map] config map
+          # @param [Thing] thing to create trigger for
+          # @param [Trigger] trigger to map with thing
+          # @param [State] to for thing
+          # @param [State] from state of thing
           #
-          # @return [OpenHAB Trigger] configured by type and supplied config
+          # @return [Array] Trigger and config for thing
           #
-          def self.trigger(type:, config:)
-            TriggerBuilder.create
-                          .with_id(uuid)
-                          .with_type_uid(type)
-                          .with_configuration(Configuration.new(config))
-                          .build
+          def trigger_for_thing(thing:, type:, to: nil, from: nil)
+            config = { 'thingUID' => thing.uid.to_s }
+            config['status'] = trigger_state_from_symbol(to).to_s if to
+            config['previousStatus'] = trigger_state_from_symbol(from).to_s if from
+            [type, config]
           end
 
           #
-          # Generate a UUID for triggers
+          # converts object to upcase string if its a symbol
+          #
+          # @param [sym] sym potential symbol to convert
           #
-          # @return [String] UUID
+          # @return [String] Upcased symbol as string
           #
-          def self.uuid
-            SecureRandom.uuid
+          def trigger_state_from_symbol(sym)
+            sym.to_s.upcase if (sym.is_a? Symbol) || sym
           end
         end
       end

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

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require_relative 'cron/cron'
+require_relative 'cron/cron_handler'
+require_relative 'changed'
+require_relative 'channel'
+require_relative 'command'
+require_relative 'updated'
+require_relative 'generic'
+require_relative 'watch/watch'
+require_relative 'watch/watch_handler'

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

@@ -21,119 +21,133 @@ module OpenHAB
         # @return [Trigger] Trigger for updated entity
         #
         def updated(*items, to: nil, attach: nil)
-          separate_groups(items).map do |item|
+          updated = Updated.new(rule_triggers: @rule_triggers)
+          Updated.flatten_items(items).map do |item|
             logger.trace("Creating updated trigger for item(#{item}) to(#{to})")
             [to].flatten.map do |to_state|
-              update_trigger(item: item, to: to_state, attach: attach)
+              updated.trigger(item: item, to: to_state, attach: attach)
             end
           end.flatten
         end
 
-        private
-
-        #
-        # Create the trigger
-        #
-        # @param [Object] item item to create trigger for
-        # @param [Item State] from state to restrict trigger to
-        # @param [Item State] to state to restrict trigger to
-        # @param attach attachment
         #
-        # @return [Trigger] OpenHAB triggers
+        # Creates updated triggers
         #
-        def update_trigger(item:, to:, attach:)
-          case to
-          when Range then create_update_range_trigger(item: item, to: to, attach: attach)
-          when Proc then create_update_proc_trigger(item: item, to: to, attach: attach)
-          else create_update_trigger(item: item, to: to, attach: attach)
+        class Updated < Trigger
+          include OpenHAB::Log
+
+          #
+          # Create the trigger
+          #
+          # @param [Object] item item to create trigger for
+          # @param [Item State] from state to restrict trigger to
+          # @param [Item State] to state to restrict trigger to
+          # @param attach attachment
+          #
+          # @return [Trigger] OpenHAB triggers
+          #
+          def trigger(item:, to:, attach:)
+            case to
+            when Range then range_trigger(item: item, to: to, attach: attach)
+            when Proc then proc_trigger(item: item, to: to, attach: attach)
+            else update_trigger(item: item, to: to, attach: attach)
+            end
           end
-        end
 
-        #
-        # Creates a trigger with a range condition on the 'to' field
-        # @param [Object] item to create changed trigger on
-        # @param [Object] to state restrict trigger to
-        # @param [Object] attach to trigger
-        # @return [Trigger] OpenHAB trigger
-        #
-        def create_update_range_trigger(item:, to:, attach:)
-          to, * = Conditions::Proc.range_procs(to)
-          create_update_proc_trigger(item: item, to: to, attach: attach)
-        end
+          private
 
-        #
-        # Creates a trigger with a proc condition on the 'to' field
-        # @param [Object] item to create changed trigger on
-        # @param [Object] to state restrict trigger to
-        # @param [Object] attach to trigger
-        # @return [Trigger] OpenHAB trigger
-        #
-        def create_update_proc_trigger(item:, to:, attach:)
-          create_update_trigger(item: item, to: nil, attach: attach).tap do |trigger|
-            @trigger_conditions[trigger.id] = Conditions::Proc.new(to: to)
+          # @return [String] A thing status update trigger
+          THING_UPDATE = 'core.ThingStatusUpdateTrigger'
+
+          # @return [String] An item state update trigger
+          ITEM_STATE_UPDATE = 'core.ItemStateUpdateTrigger'
+
+          # @return [String] A group state update trigger for items in the group
+          GROUP_STATE_UPDATE = 'core.GroupStateUpdateTrigger'
+
+          #
+          # Creates a trigger with a range condition on the 'to' field
+          # @param [Object] item to create changed trigger on
+          # @param [Object] to state restrict trigger to
+          # @param [Object] attach to trigger
+          # @return [Trigger] OpenHAB trigger
+          #
+          def range_trigger(item:, to:, attach:)
+            to, * = Conditions::Proc.range_procs(to)
+            proc_trigger(item: item, to: to, attach: attach)
           end
-        end
 
-        #
-        # Create a trigger for updates
-        #
-        # @param [Object] item Type of item [Group,Thing,Item] to create update trigger for
-        # @param [State] to_state state restriction on trigger
-        #
-        # @return [Trigger] OpenHAB triggers
-        #
-        def create_update_trigger(item:, to:, attach:)
-          trigger, config = case item
-                            when OpenHAB::DSL::Items::GroupItem::GroupMembers then group_update(item: item, to: to)
-                            when Thing then thing_update(thing: item, to: to)
-                            else item_update(item: item, to: to)
-                            end
-          append_trigger(trigger, config, attach: attach)
-        end
+          #
+          # Creates a trigger with a proc condition on the 'to' field
+          # @param [Object] item to create changed trigger on
+          # @param [Object] to state restrict trigger to
+          # @param [Object] attach to trigger
+          # @return [Trigger] OpenHAB trigger
+          #
+          def proc_trigger(item:, to:, attach:)
+            conditions = Conditions::Proc.new(to: to)
+            update_trigger(item: item, to: nil, attach: attach, conditions: conditions)
+          end
 
-        #
-        # Create an update trigger for an item
-        #
-        # @param [Item] item to create trigger for
-        # @param [State] to_state optional state restriction for target
-        #
-        # @return [Array<Hash,String>] first element is a String specifying trigger type
-        #  second element is a Hash configuring trigger
-        #
-        def item_update(item:, to:)
-          config = { 'itemName' => item.name }
-          config['state'] = to.to_s unless to.nil?
-          trigger = Trigger::ITEM_STATE_UPDATE
-          [trigger, config]
-        end
+          #
+          # Create a trigger for updates
+          #
+          # @param [Object] item Type of item [Group,Thing,Item] to create update trigger for
+          # @param [State] to_state state restriction on trigger
+          #
+          # @return [Trigger] OpenHAB triggers
+          #
+          def update_trigger(item:, to:, attach: nil, conditions: nil)
+            type, config = case item
+                           when OpenHAB::DSL::Items::GroupItem::GroupMembers then group_update(item: item, to: to)
+                           when Thing then thing_update(thing: item, to: to)
+                           else item_update(item: item, to: to)
+                           end
+            append_trigger(type: type, config: config, attach: attach, conditions: conditions)
+          end
 
-        #
-        # Create an update trigger for a group
-        #
-        # @param [Item] item to create trigger for
-        # @param [State] to_state optional state restriction for target
-        #
-        # @return [Array<Hash,String>] first element is a String specifying trigger type
-        #  second element is a Hash configuring trigger
-        #
-        def group_update(item:, to:)
-          config = { 'groupName' => item.group.name }
-          config['state'] = to.to_s unless to.nil?
-          trigger = Trigger::GROUP_STATE_UPDATE
-          [trigger, config]
-        end
+          #
+          # Create an update trigger for an item
+          #
+          # @param [Item] item to create trigger for
+          # @param [State] to_state optional state restriction for target
+          #
+          # @return [Array<Hash,String>] first element is a String specifying trigger type
+          #  second element is a Hash configuring trigger
+          #
+          def item_update(item:, to:)
+            config = { 'itemName' => item.name }
+            config['state'] = to.to_s unless to.nil?
+            [ITEM_STATE_UPDATE, config]
+          end
 
-        #
-        # Create an update trigger for a thing
-        #
-        # @param [Thing] thing to create trigger for
-        # @param [State] to_state optional state restriction for target
-        #
-        # @return [Array<Hash,String>] first element is a String specifying trigger type
-        #  second element is a Hash configuring trigger
-        #
-        def thing_update(thing:, to:)
-          trigger_for_thing(thing, Trigger::THING_UPDATE, to)
+          #
+          # Create an update trigger for a group
+          #
+          # @param [Item] item to create trigger for
+          # @param [State] to_state optional state restriction for target
+          #
+          # @return [Array<Hash,String>] first element is a String specifying trigger type
+          #  second element is a Hash configuring trigger
+          #
+          def group_update(item:, to:)
+            config = { 'groupName' => item.group.name }
+            config['state'] = to.to_s unless to.nil?
+            [GROUP_STATE_UPDATE, config]
+          end
+
+          #
+          # Create an update trigger for a thing
+          #
+          # @param [Thing] thing to create trigger for
+          # @param [State] to_state optional state restriction for target
+          #
+          # @return [Array<Hash,String>] first element is a String specifying trigger type
+          #  second element is a Hash configuring trigger
+          #
+          def thing_update(thing:, to:)
+            trigger_for_thing(thing: thing, type: THING_UPDATE, to: to)
+          end
         end
       end
     end

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

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require 'openhab/log/logger'
+require 'openhab/dsl/rules/triggers/trigger'
+
+module OpenHAB
+  module DSL
+    module Rules
+      #
+      # Module holds rule triggers
+      #
+      module Triggers
+        #
+        # Module for watching directories/files
+        #
+
+        #
+        # 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 = Watch.glob_for_path(Pathname.new(path), glob)
+          types = [binding.local_variable_get(:for)].flatten
+          config = { path: path.to_s, types: types.map(&:to_s), glob: glob.to_s }
+
+          logger.state 'Creating a watch trigger', path: path, glob: glob, types: types
+          Watch.new(rule_triggers: @rule_triggers).trigger(config: config, attach: attach)
+        end
+
+        #
+        # Creates watch triggers
+        #
+        class Watch < Trigger
+          # Characters in an fnmatch compatible glob
+          GLOB_CHARS = ['**', '*', '?', '[', ']', '{', '}'].freeze
+          private_constant :GLOB_CHARS
+
+          #
+          # 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 self.glob_for_path(path, glob)
+            # Checks if the supplied pathname last element contains a glob char
+            if 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]
+            end
+          end
+
+          #
+          # Create a watch trigger based on item type
+          #
+          # @param [Array] commands to create trigger for
+          # @param [Object] item to create trigger for
+          #
+          #
+          def trigger(config:, attach:)
+            append_trigger(type: WatchHandler::WATCH_TRIGGER_MODULE_ID,
+                           config: config,
+                           attach: attach)
+          end
+        end
+      end
+    end
+  end
+end