openhab-scripting 4.30.3 → 4.30.4

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

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/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.30.4'
 end