openhab-scripting 4.30.3 → 4.30.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5916a1adf8f4162530b88e279d0d8a8cb5cdb7f0505572258e1170ed7841460f
-  data.tar.gz: d3e9073dbde176abf8582e51eb6009a953befde6fd05b9a782fa3c3a09400ed3
+  metadata.gz: 5836c0c28481307c2e5b7e455f78e6a41db200d6d0479b6510ca920a6b4b1327
+  data.tar.gz: 3dae55830faebd93761bd1250c7d1a82c1fdb0e086fe152c9c7cb4b3791aa817
 SHA512:
-  metadata.gz: f39b84e0831b3ec13c643cc65eea2a45f2d9971fbf8ac9dc0bb53a44ab7ad767b2ab75f88dfe0db96dd274c30f40eab4f9ab876603d2e9c001f107ecec2a6d15
-  data.tar.gz: c9712062f693f5a4fd903ce8fbd06a441622850b94c240b6e5ade99a7a0754c1576ef78e69e518ec537728a7233ea8794090ace0016873628dccf5595067fb4e
+  metadata.gz: cf42c9413c725a57783cd261c89162186573739676f681e0d0a6749c461262a7dbe22fac2d7692a7c39dd36a525e75facb4345f0f61b2ee5e4ea81b09bd0875f
+  data.tar.gz: 588986cf6160cf230ffe403381cc55b267a29c9bd36f444bb38d446eddbdee7173c7f42efea39082302506eb50c92b60125a9575e19e9063f2015f42098c2ee1

data/lib/openhab/dsl/items/timed_command.rb

@@ -1,7 +1,8 @@
 # frozen_string_literal: true
 
 require 'openhab/dsl/timers'
-require 'openhab/dsl/rules/triggers/trigger'
+require 'openhab/dsl/rules/rule_triggers'
+require 'openhab/dsl/rules/triggers/triggers'
 require 'openhab/log/logger'
 require 'java'
 
@@ -151,8 +152,8 @@ module OpenHAB
               # 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_CHANGE,
+              set_triggers([OpenHAB::DSL::Rules::RuleTriggers.trigger(
+                type: OpenHAB::DSL::Rules::Triggers::Changed::ITEM_STATE_CHANGE,
                 config: { 'itemName' => timed_command_details.item.name }
               )])
             end

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

@@ -32,9 +32,8 @@ module OpenHAB
         # @param [Config] config Rule configuration
         #
         # Constructor sets a number of variables, no further decomposition necessary
-        # rubocop:disable Metrics/MethodLength
-        # Metrics disabled because only setters are called or defaults set.
-        def initialize(config:)
+        def initialize(config:) # rubocop:disable Metrics/MethodLength
+          # Metrics disabled because only setters are called or defaults set.
           super()
           set_name(config.name)
           set_description(config.description)
@@ -42,13 +41,12 @@ module OpenHAB
           @run_context = config.caller
           @run_queue = config.run
           @guard = config.guard
-          between = config.between&.yield_self { between(config.between) }
-          @between = between || OpenHAB::DSL::Between::ALL_DAY
           # Convert between to correct range or nil if not set
+          between = config.between&.then { between(config.between) }
+          @between = between || OpenHAB::DSL::Between::ALL_DAY
           @trigger_conditions = config.trigger_conditions
           @attachments = config.attachments
         end
-        # rubocop:enable Metrics/MethodLength
 
         #
         # Execute the rule

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

@@ -1,17 +1,11 @@
 # frozen_string_literal: true
 
 require 'java'
-require 'pp'
+require 'forwardable'
 require_relative 'property'
-require_relative 'triggers/cron'
-require_relative 'triggers/changed'
-require_relative 'triggers/channel'
-require_relative 'triggers/command'
-require_relative 'triggers/updated'
-require_relative 'triggers/generic'
-require_relative 'triggers/watch'
-require_relative 'triggers/conditions/proc'
+require_relative 'triggers/triggers'
 require_relative 'guard'
+require_relative 'rule_triggers'
 require 'openhab/core/entity_lookup'
 require 'openhab/dsl/between'
 require 'openhab/dsl/dsl'
@@ -33,15 +27,10 @@ module OpenHAB
         include OpenHAB::DSL::Rules::Guard
         include OpenHAB::DSL::Rules::Property
         extend OpenHAB::DSL
+        extend Forwardable
 
-        # @return [Array] Of triggers
-        attr_accessor :triggers
-
-        # @return [Array] Of trigger delays
-        attr_reader :trigger_conditions
-
-        # @return [Hash] Hash of trigger UIDs to attachments
-        attr_reader :attachments
+        # Provide backwards compatibility for these fields
+        delegate %i[triggers trigger_conditions attachments] => :@rule_triggers
 
         # @return [Array] Of trigger guards
         attr_accessor :guard
@@ -86,9 +75,7 @@ module OpenHAB
         #   Used to execute within the object's context
         #
         def initialize(rule_name, caller_binding)
-          @triggers = []
-          @trigger_conditions = Hash.new(OpenHAB::DSL::Rules::Triggers::Conditions::Proc::ANY)
-          @attachments = {}
+          @rule_triggers = RuleTriggers.new
           @caller = caller_binding.eval 'self'
           name(rule_name)
           enabled(true)
@@ -147,8 +134,8 @@ module OpenHAB
             "Run blocks: (#{run}) " \
             "on_start: (#{on_start?}) " \
             "Trigger Conditions: #{trigger_conditions} " \
-            "Trigger UIDs: #{triggers.map(&:id).join(', ')}" \
-            "Attachments: #{attachments} "
+            "Trigger UIDs: #{triggers.map(&:id).join(', ')} " \
+            "Attachments: #{attachments}"
         end
       end
     end

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

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+require 'forwardable'
+require 'java'
+require 'securerandom'
+require 'openhab/log/logger'
+require_relative 'triggers/conditions/proc'
+
+module OpenHAB
+  module DSL
+    #
+    # Creates and manages OpenHAB Rules
+    #
+    module Rules
+      #
+      # Rule configuration for OpenHAB Rules engine
+      #
+      class RuleTriggers
+        include OpenHAB::Log
+
+        java_import org.openhab.core.automation.util.TriggerBuilder
+        java_import org.openhab.core.config.core.Configuration
+
+        # @return [Array] Of triggers
+        attr_accessor :triggers
+
+        # @return [Hash] Of trigger conditions
+        attr_reader :trigger_conditions
+
+        # @return [Hash] Hash of trigger UIDs to attachments
+        attr_reader :attachments
+
+        #
+        # Create a new RuleTrigger
+        #
+        # @param [Object] caller_binding The object initializing this configuration.
+        #   Used to execute within the object's context
+        #
+        def initialize
+          @triggers = []
+          @trigger_conditions = Hash.new(OpenHAB::DSL::Rules::Triggers::Conditions::Proc::ANY)
+          @attachments = {}
+        end
+
+        #
+        # Append a trigger to the list of triggers
+        #
+        # @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, conditions: nil)
+          config.transform_keys!(&:to_s)
+          RuleTriggers.trigger(type: type, config: config).tap do |trigger|
+            logger.trace("Appending trigger (#{trigger}) attach (#{attach}) conditions(#{conditions})")
+            @triggers << trigger
+            @attachments[trigger.id] = attach if attach
+            @trigger_conditions[trigger.id] = conditions if conditions
+          end
+        end
+
+        #
+        # Create a trigger
+        #
+        # @param [String] type of trigger
+        # @param [Map] config map
+        #
+        # @return [OpenHAB Trigger] configured by type and supplied config
+        #
+        def self.trigger(type:, config:)
+          logger.trace("Creating trigger of type '#{type}' config: #{config}")
+          TriggerBuilder.create
+                        .with_id(uuid)
+                        .with_type_uid(type)
+                        .with_configuration(Configuration.new(config))
+                        .build
+        end
+
+        #
+        # Generate a UUID for triggers
+        #
+        # @return [String] UUID
+        #
+        def self.uuid
+          SecureRandom.uuid
+        end
+
+        #
+        # Inspect the config object
+        #
+        # @return [String] details of the config object
+        #
+        def inspect
+          "Triggers: (#{triggers}) " \
+            "Trigger Conditions: #{trigger_conditions} " \
+            "Trigger UIDs: #{triggers.map(&:id).join(', ')}" \
+            "Attachments: #{attachments} "
+        end
+      end
+    end
+  end
+end

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

@@ -3,6 +3,7 @@
 require 'openhab/log/logger'
 require_relative 'conditions/duration'
 require_relative 'conditions/proc'
+require_relative 'trigger'
 
 module OpenHAB
   module DSL
@@ -25,180 +26,191 @@ module OpenHAB
         # @return [Trigger] OpenHAB trigger
         #
         def changed(*items, to: nil, from: nil, for: nil, attach: nil)
-          separate_groups(items).map do |item|
+          changed = Changed.new(rule_triggers: @rule_triggers)
+          Changed.flatten_items(items).map do |item|
             logger.trace("Creating changed trigger for entity(#{item}), to(#{to}), from(#{from})")
 
             # for is a reserved word in ruby, so use local_variable_get :for
             wait_duration = binding.local_variable_get(:for)
 
-            each_state(from, to) do |from_state, to_state|
-              changed_trigger(item, from_state, to_state, wait_duration, attach)
+            Changed.each_state(from, to) do |from_state, to_state|
+              changed.trigger(item: item, from: from_state, to: to_state, duration: wait_duration, attach: attach)
             end
           end.flatten
         end
 
-        private
-
-        #
-        # Run block for each state combination
-        #
-        # @param [Item State, Array<Item State>] from state to restrict trigger to
-        # @param [Item State, Array<Item State>] to state to restrict trigger to
-        #
-        # @yieldparam [Item State] from_state from state
-        # @yieldparam [Item State] to_state to state
         #
-        # @return [Array] array of block return values
-        #
-        def each_state(from, to)
-          [to].flatten.each_with_object([]) do |to_state, agg|
-            [from].flatten.each do |from_state|
-              agg.push(yield(from_state, to_state))
+        # Creates changed triggers
+        #
+        class Changed < Trigger
+          #
+          # Run block for each state combination
+          #
+          # @param [Item State, Array<Item State>] from state to restrict trigger to
+          # @param [Item State, Array<Item State>] to state to restrict trigger to
+          #
+          # @yieldparam [Item State] from_state from state
+          # @yieldparam [Item State] to_state to state
+          #
+          # @return [Array] array of block return values
+          #
+          def self.each_state(from, to)
+            [to].flatten.each_with_object([]) do |to_state, agg|
+              [from].flatten.each do |from_state|
+                agg.push(yield(from_state, to_state))
+              end
             end
           end
-        end
 
-        #
-        # 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 [OpenHAB::Core::Duration, nil] duration ruration to delay trigger until to state is met
-        # @param attach attachment
-        #
-        # @return [Trigger] OpenHAB triggers
-        #
-        def changed_trigger(item, from, to, duration, attach)
-          if duration
-            changed_wait(item, from: from, to: to, duration: duration, attach: attach)
-          elsif [to, from].grep(Range).any?
-            create_changed_range_trigger(item, from: from, to: to, attach: attach)
-          elsif [to, from].grep(Proc).any?
-            create_changed_proc_trigger(item, from: from, to: to, attach: attach)
-          else
-            create_changed_trigger(item, from, to, attach)
+          #
+          # 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 [OpenHAB::Core::Duration, nil] duration ruration to delay trigger until to state is met
+          # @param attach attachment
+          #
+          # @return [Trigger] OpenHAB triggers
+          #
+          def trigger(item:, from:, to:, duration:, attach:)
+            if duration
+              wait_trigger(item: item, from: from, to: to, duration: duration, attach: attach)
+            elsif [to, from].grep(Range).any?
+              range_trigger(item: item, from: from, to: to, attach: attach)
+            elsif [to, from].grep(Proc).any?
+              proc_trigger(item: item, from: from, to: to, attach: attach)
+            else
+              changed_trigger(item: item, from: from, to: to, attach: attach)
+            end
           end
-        end
 
-        #
-        # Create a TriggerDelay for for an item or group that is changed for a specific duration
-        #
-        # @param [Object] item to create trigger delay for
-        # @param [OpenHAB::Core::Duration] duration to delay trigger for until condition is met
-        # @param [Item State] to OpenHAB Item State item or group needs to change to
-        # @param [Item State] from OpenHAB Item State item or group needs to be coming from
-        # @param [Object] attach to trigger
-        #
-        # @return [Trigger] OpenHAB trigger
-        #
-        def changed_wait(item, duration:, to: nil, from: nil, attach: nil)
-          item_name = item.respond_to?(:name) ? item.name : item.to_s
-          logger.trace("Creating Changed Wait Change Trigger for Item(#{item_name}) Duration(#{duration}) "\
-                       "To(#{to}) From(#{from}) Attach(#{attach})")
-          create_changed_trigger(item, nil, nil, attach).tap do |trigger|
-            @trigger_conditions[trigger.id] = Conditions::Duration.new(to: to, from: from, duration: duration)
+          private
+
+          # @return [String] A thing status Change trigger
+          THING_CHANGE = 'core.ThingStatusChangeTrigger'
+
+          # @return [String] An item state change trigger
+          ITEM_STATE_CHANGE = 'core.ItemStateChangeTrigger'
+
+          # @return [String] A group state change trigger for items in the group
+          GROUP_STATE_CHANGE = 'core.GroupStateChangeTrigger'
+
+          #
+          # Create a TriggerDelay for for an item or group that is changed for a specific duration
+          #
+          # @param [Object] item to create trigger delay for
+          # @param [OpenHAB::Core::Duration] duration to delay trigger for until condition is met
+          # @param [Item State] to OpenHAB Item State item or group needs to change to
+          # @param [Item State] from OpenHAB Item State item or group needs to be coming from
+          # @param [Object] attach to trigger
+          #
+          # @return [Trigger] OpenHAB trigger
+          #
+          def wait_trigger(item:, duration:, to: nil, from: nil, attach: nil)
+            item_name = item.respond_to?(:name) ? item.name : item.to_s
+            logger.trace("Creating Changed Wait Change Trigger for Item(#{item_name}) Duration(#{duration}) "\
+                         "To(#{to}) From(#{from}) Attach(#{attach})")
+            conditions = Conditions::Duration.new(to: to, from: from, duration: duration)
+            changed_trigger(item: item, to: nil, from: nil, attach: attach, conditions: conditions)
           end
-        end
 
-        #
-        # Creates a trigger with a range condition on either 'from' or 'to' field
-        # @param [Object] item to create changed trigger on
-        # @param [Object] from state to restrict trigger to
-        # @param [Object] to state restrict trigger to
-        # @param [Object] attach to trigger
-        # @return [Trigger] OpenHAB trigger
-        #
-        def create_changed_range_trigger(item, from:, to:, attach:)
-          from, to = Conditions::Proc.range_procs(from, to)
-          create_changed_proc_trigger(item, from: from, to: to, attach: attach)
-        end
+          #
+          # Creates a trigger with a range condition on either 'from' or 'to' field
+          # @param [Object] item to create changed trigger on
+          # @param [Object] from state to restrict trigger to
+          # @param [Object] to state restrict trigger to
+          # @param [Object] attach to trigger
+          # @return [Trigger] OpenHAB trigger
+          #
+          def range_trigger(item:, from:, to:, attach:)
+            from, to = Conditions::Proc.range_procs(from, to)
+            proc_trigger(item: item, from: from, to: to, attach: attach)
+          end
 
-        #
-        # Creates a trigger with a proc condition on either 'from' or 'to' field
-        # @param [Object] item to create changed trigger on
-        # @param [Object] from state to restrict trigger to
-        # @param [Object] to state restrict trigger to
-        # @param [Object] attach to trigger
-        # @return [Trigger] OpenHAB trigger
-        #
-        def create_changed_proc_trigger(item, from:, to:, attach:)
-          # swap from/to w/ nil if from/to is a proc
-          # rubocop:disable Style/ParallelAssignment
-          from_proc, from = from, nil if from.is_a? Proc
-          to_proc, to = to, nil if to.is_a? Proc
-          # rubocop:enable Style/ParallelAssignment
-          trigger = create_changed_trigger(item, from, to, attach)
-          @trigger_conditions[trigger.id] = Conditions::Proc.new(to: to_proc, from: from_proc)
-          trigger
-        end
+          #
+          # Creates a trigger with a proc condition on either 'from' or 'to' field
+          # @param [Object] item to create changed trigger on
+          # @param [Object] from state to restrict trigger to
+          # @param [Object] to state restrict trigger to
+          # @param [Object] attach to trigger
+          # @return [Trigger] OpenHAB trigger
+          #
+          def proc_trigger(item:, from:, to:, attach:)
+            # swap from/to w/ nil if from/to is a proc
+            # rubocop:disable Style/ParallelAssignment
+            from_proc, from = from, nil if from.is_a? Proc
+            to_proc, to = to, nil if to.is_a? Proc
+            # rubocop:enable Style/ParallelAssignment
+            conditions = Conditions::Proc.new(to: to_proc, from: from_proc)
+            changed_trigger(item: item, from: from, to: to, attach: attach, conditions: conditions)
+          end
 
-        #
-        # Create a changed trigger
-        #
-        # @param [Object] item to create changed trigger on
-        # @param [Object] from state to restrict trigger to
-        # @param [Object] to state restrict trigger to
-        #
-        #
-        def create_changed_trigger(item, from, to, attach)
-          trigger, config = case item
-                            when OpenHAB::DSL::Items::GroupItem::GroupMembers
-                              create_group_changed_trigger(item, from, to)
-                            when Thing then create_thing_changed_trigger(item, from, to)
-                            else create_item_changed_trigger(item, from, to)
-                            end
-          append_trigger(trigger, config, attach: attach)
-        end
+          #
+          # Create a changed trigger
+          #
+          # @param [Object] item to create changed trigger on
+          # @param [Object] from state to restrict trigger to
+          # @param [Object] to state restrict trigger to
+          #
+          #
+          def changed_trigger(item:, from:, to:, attach: nil, conditions: nil)
+            type, config = case item
+                           when OpenHAB::DSL::Items::GroupItem::GroupMembers then group(group: item, from: from,
+                                                                                        to: to)
+                           when Thing then thing(thing: item, from: from, to: to)
+                           else item(item: item, from: from, to: to)
+                           end
+            append_trigger(type: type, config: config, attach: attach, conditions: conditions)
+          end
 
-        #
-        # Create a changed trigger for a thing
-        #
-        # @param [Thing] thing to detected changed states on
-        # @param [String] from state to restrict trigger to
-        # @param [String] to state to restrict trigger to
-        #
-        # @return [Array<Hash,String>] first element is a String specifying trigger type
-        #  second element is a Hash configuring trigger
-        #
-        def create_thing_changed_trigger(thing, from, to)
-          trigger_for_thing(thing, Trigger::THING_CHANGE, to, from)
-        end
+          #
+          # Create a changed trigger for a thing
+          #
+          # @param [Thing] thing to detected changed states on
+          # @param [String] from state to restrict trigger to
+          # @param [String] to state to restrict trigger to
+          #
+          # @return [Array<Hash,String>] first element is a String specifying trigger type
+          #  second element is a Hash configuring trigger
+          #
+          def thing(thing:, from:, to:)
+            trigger_for_thing(thing: thing, type: THING_CHANGE, to: to, from: from)
+          end
 
-        #
-        # Create a changed trigger for an item
-        #
-        # @param [Item] item to detected changed states on
-        # @param [String] from state to restrict trigger to
-        # @param [String] to to restrict trigger to
-        #
-        # @return [Array<Hash,String>] first element is a String specifying trigger type
-        #  second element is a Hash configuring trigger
-        #
-        def create_item_changed_trigger(item, from, to)
-          config = { 'itemName' => item.name }
-          config['state'] = to.to_s if to
-          config['previousState'] = from.to_s if from
-          trigger = Trigger::ITEM_STATE_CHANGE
-          [trigger, config]
-        end
+          #
+          # Create a changed trigger for an item
+          #
+          # @param [Item] item to detected changed states on
+          # @param [String] from state to restrict trigger to
+          # @param [String] to to restrict trigger to
+          #
+          # @return [Array<Hash,String>] first element is a String specifying trigger type
+          #  second element is a Hash configuring trigger
+          #
+          def item(item:, from:, to:)
+            config = { 'itemName' => item.name }
+            config['state'] = to.to_s if to
+            config['previousState'] = from.to_s if from
+            [ITEM_STATE_CHANGE, config]
+          end
 
-        #
-        # Create a changed trigger for group items
-        #
-        # @param [Group] group to detected changed states on
-        # @param [String] from state to restrict trigger to
-        # @param [String] to to restrict trigger to
-        #
-        # @return [Array<Hash,String>] first element is a String specifying trigger type
-        #  second element is a Hash configuring trigger
-        #
-        def create_group_changed_trigger(group, from, to)
-          config = { 'groupName' => group.group.name }
-          config['state'] = to.to_s if to
-          config['previousState'] = from.to_s if from
-          trigger = Trigger::GROUP_STATE_CHANGE
-          [trigger, config]
+          #
+          # Create a changed trigger for group items
+          #
+          # @param [Group] group to detected changed states on
+          # @param [String] from state to restrict trigger to
+          # @param [String] to to restrict trigger to
+          #
+          # @return [Array<Hash,String>] first element is a String specifying trigger type
+          #  second element is a Hash configuring trigger
+          #
+          def group(group:, from:, to:)
+            config = { 'groupName' => group.group.name }
+            config['state'] = to.to_s if to
+            config['previousState'] = from.to_s if from
+            [GROUP_STATE_CHANGE, config]
+          end
         end
       end
     end