openhab-scripting 5.1.1 → 5.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 17db43cc91f70e705ab8002d2653afe72cad963ad92907d9535ee906082cca97
-  data.tar.gz: 0cf4c4c56fbf427fbf37a47571b20294176b29a89140428cb2b6f29c495c5a92
+  metadata.gz: 3d56223cd6766da527070ec31571d7a22cffa7d69ec754a1a1dbeb06c9354d56
+  data.tar.gz: c635cf86c119c54c4b665f28cd91b0804a58c868d23f7a99420d4183f60bf195
 SHA512:
-  metadata.gz: 0a20f62e3c416f1801d92216a64495737cacb017257644506040c8412908ffa15575356707c947757160b9d03ff340a6c8abeab25924bdca2f79979f63b0a148
-  data.tar.gz: ce9de9508194ae985223f92457184bb1c42af089605171950d13cdbf93d132a1955dcd8d9773a9749272ec13a3c956d4b0788e1cc632e50900204568c0276181
+  metadata.gz: 79e7ac98695e1fb75a6bf100226a555d2d1d8f7a96efa0779b42439e262bfb63777ee99545782885f509c08f21dc77b2b504fd13078a5e5bc1d82ce456e3cca9
+  data.tar.gz: d735f987f2540cba7b358a4f0550ed723ef807b0a4c5e12ab21177cc844f65a2eec1080778b996e702cd72a5d744b1a7c97fe52ba5679a17a13b4988ccd2bf76

data/lib/openhab/core/actions/audio.rb

@@ -23,14 +23,8 @@ module OpenHAB
           #
           def play_sound(filename, sink: nil, volume: nil)
             volume = PercentType.new(volume) unless volume.is_a?(PercentType) || volume.nil?
-            # JRuby calls the wrong overloaded method when volume is given, but sink is nil
-            # will call playSound(String, String, float) instead of playSound(String, String, PercentType)
-            # and end up with argument type mismatched. So we need to give it a bit of help here.
-            if sink
-              playSound(sink.to_s, filename.to_s, volume)
-            else
-              playSound(filename.to_s, volume)
-            end
+            java_send :playSound, [java.lang.String, java.lang.String, PercentType.java_class],
+                      sink, filename.to_s, volume
           end
 
           #

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

@@ -923,9 +923,9 @@ module OpenHAB
         # triggering element was an item or a thing.
         #
         # @param [Item, GroupItem::Members, Thing] items Objects to create trigger for.
-        # @param [State, Array<State>, Range, Proc] from
+        # @param [State, Array<State>, #===, nil] from
         #   Only execute rule if previous state matches `from` state(s).
-        # @param [State, Array<State>, Range, Proc] to State(s) for
+        # @param [State, Array<State>, #===, nil] to State(s) for
         #   Only execute rule if new state matches `to` state(s).
         # @param [java.time.temporal.TemporalAmount] for
         #   Duration item must remain in the same state before executing the execution blocks.
@@ -982,6 +982,12 @@ module OpenHAB
         #     run { logger.info("Alarm Mode Updated") }
         #   end
         #
+        # @example Works with regexes:
+        #   rule "Execute when item state is changed to something matching a regex" do
+        #     changed Alarm_Mode, to: /armed/
+        #     run { logger.info("Alarm armed") }
+        #   end
+        #
         # @example Works with Things:
         #   rule "Execute rule when thing is changed" do
         #     changed things["astro:sun:home"], :from => :online, :to => :uninitialized
@@ -1299,8 +1305,8 @@ module OpenHAB
         # {Core::Events::ItemCommandEvent}.
         #
         # @param [Item, GroupItem::Members] items Items to create trigger for
-        # @param [Core::TypesCommand, Array<Command>, Range, Proc] command commands to match for trigger
-        # @param [Array<Command>, Range, Proc] commands Fluent alias for `command`
+        # @param [Core::Types::Command, Array<Core::Types::Command>, #===, nil] command commands to match for trigger
+        # @param [Array<Core::Types::Command>, #===, nil] commands Fluent alias for `command`
         # @param [Object] attach object to be attached to the trigger
         # @return [void]
         #
@@ -1358,6 +1364,12 @@ module OpenHAB
         #     run { |event| logger.info("Item received command: #{event.command}" ) }
         #   end
         #
+        # @example Works with regexes
+        #   rule 'Execute rule when Alarm Mode command matches a substring' do
+        #     received_command Alarm_Mode, command: /arm/
+        #     run { |event| logger.info("Item received command: #{event.command}" ) }
+        #   end
+        #
         def received_command(*items, command: nil, commands: nil, attach: nil)
           command_trigger = Command.new(rule_triggers: @rule_triggers)
 
@@ -1604,7 +1616,7 @@ module OpenHAB
         #
         # @param [Item, GroupItem::Members, Thing] items
         #   Objects to create trigger for.
-        # @param [State, Array<State>, Range, Proc, Symbol, String] to
+        # @param [State, Array<State>, Symbol, String, #===, nil] to
         #   Only execute rule if the state matches `to` state(s). If the
         #   updated element is a {Core::Things::Thing}, the `to` accepts
         #   symbols and strings that match
@@ -1666,6 +1678,12 @@ module OpenHAB
         #     triggered { |item| logger.info("Group item #{item.name} updated")}
         #   end
         #
+        # @example Works with regexes:
+        #   rule 'Execute rule when member of group is changed to a substring' do
+        #     updated AlarmModes.members, to: /armed/
+        #     triggered { |item| logger.info("Group item #{item.name} updated")}
+        #   end
+        #
         # @example Works with things as well
         #   rule 'Execute rule when thing is updated' do
         #      updated things['astro:sun:home'], :to => :uninitialized

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

@@ -4,7 +4,7 @@ require "forwardable"
 
 require "securerandom"
 
-require_relative "triggers/conditions/proc"
+require_relative "triggers/conditions/generic"
 
 module OpenHAB
   module DSL
@@ -28,7 +28,7 @@ module OpenHAB
         #
         def initialize
           @triggers = []
-          @trigger_conditions = Hash.new(Triggers::Conditions::Proc::ANY)
+          @trigger_conditions = Hash.new(Triggers::Conditions::Generic::ANY)
           @attachments = {}
         end
 

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

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "conditions/duration"
-require_relative "conditions/proc"
+require_relative "conditions/generic"
 require_relative "trigger"
 
 module OpenHAB
@@ -17,8 +17,8 @@ module OpenHAB
           # Create the trigger
           #
           # @param [Core::Items::Item, Core::Items::GroupItem::Members] item item to create trigger for
-          # @param [Core::Types::State, Array<Core::Types::State>, Range, Proc] from state to restrict trigger to
-          # @param [Core::Types::State, Array<Core::Types::State>, Range, Proc] to state to restrict trigger to
+          # @param [Core::Types::State, Symbol, #===, nil] from state to restrict trigger to
+          # @param [Core::Types::State, Symbol, #===, nil] to state to restrict trigger to
           # @param [Duration, nil] duration duration to delay trigger until to state is met
           # @param [Object] attach object to be attached to the trigger
           #
@@ -26,13 +26,19 @@ module OpenHAB
           #
           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)
+              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, from: nil, to: nil, attach: attach, conditions: conditions)
             else
-              changed_trigger(item: item, from: from, to: to, attach: attach)
+              # swap from/to w/ nil if from/to need to be processed in Ruby
+              # rubocop:disable Style/ParallelAssignment
+              from_proc, from = from, nil unless Conditions.state?(from)
+              to_proc, to = to, nil unless Conditions.state?(to)
+              # rubocop:enable Style/ParallelAssignment
+              conditions = Conditions::Generic.new(from: from_proc, to: to_proc) unless from_proc.nil? && to_proc.nil?
+              changed_trigger(item: item, from: from, to: to, attach: attach, conditions: conditions)
             end
           end
 
@@ -40,71 +46,21 @@ module OpenHAB
 
           # @return [String] A thing status Change trigger
           THING_CHANGE = "core.ThingStatusChangeTrigger"
+          private_constant :THING_CHANGE
 
           # @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 [Core::Items::Item, Core::Items::GroupItem::Members] item to create trigger delay for
-          # @param [Duration] duration to delay trigger for until condition is met
-          # @param [Core::Types::State, Array<Core::Types::State>, Range, Proc] to
-          #   State item or group needs to change to
-          # @param [Core::Types::State, Array<Core::Types::State>, Range, Proc] from
-          #   State item or group needs to be coming from
-          # @param [Object] attach object to be attached to the trigger
-          #
-          # @return [org.openhab.core.automation.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
-
-          #
-          # Creates a trigger with a range condition on either 'from' or 'to' field
-          # @param [Core::Items::Item, Core::Items::GroupItem::Members] item to create changed trigger on
-          # @param [Range] from state to restrict trigger to
-          # @param [Range] to state restrict trigger to
-          # @param [Object] attach object to be attached to the trigger
-          # @return [org.openhab.core.automation.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 [Core::Items::Item, Core::Items::GroupItem::Members] item to create changed trigger on
-          # @param [Proc] from state to restrict trigger to
-          # @param [Proc] to state restrict trigger to
-          # @param [Object] attach object to be attached to the trigger
-          # @return [org.openhab.core.automation.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
+          private_constant :GROUP_STATE_CHANGE
 
           #
           # Create a changed trigger
           #
           # @param [Core::Items::Item, Core::Items::GroupItem::Members] item to create changed trigger on
-          # @param [Core::Items::State, Array<Core::Items::State>] from state to restrict trigger to
-          # @param [Core::Items::State, Array<Core::Items::State>] to state restrict trigger to
+          # @param [Core::Types::State, #===, nil] from state to restrict trigger to
+          # @param [Core::Types::State, #===, nil] to state restrict trigger to
           # @param [Object] attach object to be attached to the trigger
           # @return [org.openhab.core.automation.Trigger]
           #

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

@@ -15,92 +15,32 @@ module OpenHAB
           # Create a received command trigger
           #
           # @param [Object] item item to create trigger for
-          # @param [Object] command to check against
+          # @param [Core::Types::State, Symbol, #===, nil] command to check against
           # @param [Object] attach object to be attached to the trigger
           #
           # @return [org.openhab.core.automation.Trigger]
           #
           def trigger(item:, command:, attach:)
-            case command
-            when Range then range_trigger(item: item, command: command, attach: attach)
-            when Proc then proc_trigger(item: item, command: command, attach: attach)
-            else command_trigger(item: item, command: command, attach: attach)
+            unless Conditions.state?(command)
+              conditions = Conditions::Generic.new(command: command)
+              command = nil
             end
-          end
-
-          #
-          # Creates a trigger with a range condition on the 'command' field
-          # @param [Object] item to create changed trigger on
-          # @param [Range] command to restrict trigger to
-          # @param [Object] attach object to be attached to the trigger
-          # @return [org.openhab.core.automation.Trigger]
-          #
-          def range_trigger(item:, command:, attach:)
-            command_range, * = Conditions::Proc.range_procs(command)
-            proc_trigger(item: item, command: command_range, attach: attach)
-          end
-
-          #
-          # Creates a trigger with a proc condition on the 'command' field
-          # @param [Object] item to create changed trigger on
-          # @param [Object] command to restrict trigger to
-          # @param [Object] attach object to be attached to the trigger
-          # @return [org.openhab.core.automation.Trigger]
-          #
-          def proc_trigger(item:, command:, attach:)
-            conditions = Conditions::Proc.new(command: command)
-            command_trigger(item: item, command: nil, attach: attach, conditions: conditions)
-          end
 
-          #
-          # Create a received trigger based on item type
-          #
-          # @param [Object] item to create trigger for
-          # @param [String] command to create trigger for
-          # @param [Object] attach object to be attached to the trigger
-          # @return [org.openhab.core.automation.Trigger]
-          #
-          def command_trigger(item:, command:, attach: nil, conditions: nil)
             type, config = if item.is_a?(GroupItem::Members)
-                             group(group: item)
+                             [GROUP_COMMAND, { "groupName" => item.group.name }]
                            else
-                             item(item: item)
+                             [ITEM_COMMAND, { "itemName" => item.name }]
                            end
             config["command"] = command.to_s unless command.nil?
             append_trigger(type: type, config: config, attach: attach, conditions: conditions)
           end
 
-          private
-
           # @return [String] item command trigger
           ITEM_COMMAND = "core.ItemCommandTrigger"
 
           # @return [String] A group command trigger for items in the group
           GROUP_COMMAND = "core.GroupCommandTrigger"
-
-          #
-          # Create trigger for item commands
-          #
-          # @param [Item] item to create trigger for
-          #
-          # @return [Array<Hash,Trigger>] first element is hash of trigger config properties
-          #   second element is trigger type
-          #
-          def item(item:)
-            [ITEM_COMMAND, { "itemName" => item.name }]
-          end
-
-          #
-          # Create trigger for group items
-          #
-          # @param [GroupItem::Members] group to create trigger for
-          #
-          # @return [Array<Hash,Trigger>] first element is hash of trigger config properties
-          #   second element is trigger type
-          #
-          def group(group:)
-            [GROUP_COMMAND, { "groupName" => group.group.name }]
-          end
+          private_constant :GROUP_COMMAND
         end
       end
     end

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

@@ -19,11 +19,9 @@ module OpenHAB
             # @param [java.time.temporal.TemporalAmount] duration to state must stay at specific value before triggering
             #
             def initialize(to:, from:, duration:)
-              to = Conditions::Proc.from_value(to)
-              from = Conditions::Proc.from_value(from)
-              @conditions = Conditions::Proc.new(to: to, from: from)
+              @conditions = Generic.new(to: to, from: from)
               @duration = duration
-              @timer = nil
+              @timers = {}
               logger.trace "Created Duration Condition To(#{to}) From(#{from}) " \
                            "Conditions(#{@conditions}) Duration(#{@duration})"
             end
@@ -32,9 +30,10 @@ module OpenHAB
             # @param [Hash] inputs inputs from trigger
             #
             def process(mod:, inputs:, &block)
-              if @timer&.active?
-                process_active_timer(inputs, mod, &block)
-              elsif check_trigger_guards(inputs)
+              timer = @timers[inputs["triggeringItem"]&.name]
+              if timer&.active?
+                process_active_timer(timer, inputs, mod, &block)
+              elsif @conditions.process(mod: mod, inputs: inputs)
                 logger.trace("Trigger Guards Matched for #{self}, delaying rule execution")
                 # Add timer and attach timer to delay object, and also state being tracked to so
                 # timer can be cancelled if state changes
@@ -49,38 +48,11 @@ module OpenHAB
             #
             # Cancels the timer, if it's active
             def cleanup
-              @timer&.cancel
+              @timers.each_value(&:cancel)
             end
 
             private
 
-            #
-            # Check if trigger guards prevent rule execution
-            #
-            # @param [java.util.Map] inputs map object describing rule trigger
-            #
-            # @return [true,false] True if the rule should execute, false if trigger guard prevents execution
-            #
-            def check_trigger_guards(inputs)
-              new_state, old_state = retrieve_states(inputs)
-              @conditions.check_from(state: old_state) && @conditions.check_to(state: new_state)
-            end
-
-            #
-            # Rerieve the newState and oldState, alternatively newStatus and oldStatus
-            # from the input map
-            #
-            # @param [java.util.Map] inputs map object describing rule trigger
-            #
-            # @return [Array] An array of the values for [newState, oldState] or [newStatus, oldStatus]
-            #
-            def retrieve_states(inputs)
-              new_state = inputs["newState"] || inputs["newStatus"]&.to_s&.downcase&.to_sym
-              old_state = inputs["oldState"] || inputs["oldStatus"]&.to_s&.downcase&.to_sym
-
-              [new_state, old_state]
-            end
-
             #
             # Creates a timer for trigger delays
             #
@@ -90,13 +62,14 @@ module OpenHAB
             #
             def create_trigger_delay_timer(inputs, _mod)
               logger.trace("Creating timer for trigger delay #{self}")
-              @timer = DSL.after(@duration) do
+              item_name = inputs["triggeringItem"]&.name
+              @timers[item_name] = DSL.after(@duration) do
                 logger.trace("Delay Complete for #{self}, executing rule")
-                @timer = nil
+                @timers.delete(item_name)
                 yield
               end
               rule.on_removal(self)
-              _, @tracking_from = retrieve_states(inputs)
+              @tracking_from = Conditions.old_state_from(inputs)
             end
 
             #
@@ -105,13 +78,14 @@ module OpenHAB
             # @param [Hash] inputs rule trigger inputs
             # @param [Hash] mod rule trigger mods
             #
-            def process_active_timer(inputs, mod, &block)
-              new_state, old_state = retrieve_states(inputs)
-              if new_state != @tracking_from && @conditions.check_to(inputs: {})
+            def process_active_timer(timer, inputs, mod, &block)
+              old_state = Conditions.old_state_from(inputs)
+              new_state = Conditions.new_state_from(inputs)
+              if new_state != @tracking_from && @conditions.process(mod: nil, inputs: { "state" => new_state })
                 logger.trace("Item changed from #{old_state} to #{new_state} for #{self}, keep waiting.")
               else
                 logger.trace("Item changed from #{old_state} to #{new_state} for #{self}, canceling timer.")
-                @timer.cancel
+                timer.cancel
                 # Reprocess trigger delay after canceling to track new state (if guards matched, etc)
                 process(mod: mod, inputs: inputs, &block)
               end

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

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module OpenHAB
+  module DSL
+    module Rules
+      module Triggers
+        # @!visibility private
+        module Conditions
+          #
+          # This creates trigger conditions that work on procs
+          #
+          class Generic
+            #
+            # Create a new Condition that executes only if procs return true
+            # @param [#===, nil] from Value to check against `from` state
+            # @param [#===, nil] to Value to check against `to` state
+            # @param [#===, nil] command Value to check against received command
+            #
+            def initialize(from: nil, to: nil, command: nil)
+              @from = from
+              @to = to
+              @command = command
+            end
+
+            ANY = Generic.new.freeze # this needs to be defined _after_ initialize so its instance variables are set
+
+            #
+            # Process rule
+            # @param [Hash] inputs inputs from trigger
+            # @return [true, false] if the conditions passed (and therefore the block was run)
+            #
+            def process(mod:, inputs:) # rubocop:disable Lint/UnusedMethodArgument - mod is unused here but required
+              logger.trace("Checking #{inputs} against condition trigger #{self}")
+              unless check_value(Conditions.old_state_from(inputs), @from) &&
+                     check_value(Conditions.new_state_from(inputs), @to) &&
+                     check_value(inputs["command"], @command)
+                return false
+              end
+
+              yield if block_given?
+              true
+            end
+
+            private
+
+            def check_value(value, expected_value)
+              return true if value.nil?
+
+              return true if expected_value.nil?
+
+              # works for procs, ranges, regexes, etc.
+              expected_value === value # rubocop:disable Style/CaseEquality
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module OpenHAB
+  module DSL
+    module Rules
+      module Triggers
+        # @!visibility private
+        module Conditions
+          class << self
+            # If a given value can be passed directly to openHAB's trigger handler configuration
+            # @return [true, false]
+            def state?(value)
+              value.nil? ||
+                value.is_a?(Core::Types::Type) ||
+                value.is_a?(String) ||
+                value.is_a?(Symbol) ||
+                value.is_a?(Numeric)
+            end
+
+            # Retrieves the previous item state or things status from inputs
+            # @return [Core::Types::Type, Symbol, nil]
+            def old_state_from(inputs)
+              inputs["oldState"] || inputs["oldStatus"]&.to_s&.downcase&.to_sym
+            end
+
+            # Retrieves the new item state or thing status from inputs
+            # @return [Core::Types::Type, Symbol, nil]
+            def new_state_from(inputs)
+              inputs["newState"] || inputs["state"] || inputs["newStatus"]&.to_s&.downcase&.to_sym
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -15,75 +15,42 @@ module OpenHAB
           # Create the trigger
           #
           # @param [Object] item item to create trigger for
-          # @param [Item State] to state to restrict trigger to
+          # @param [Core::Types::State, Symbol, #===, nil] to state to restrict trigger to
           # @param [Object] attach object to be attached to the trigger
           #
           # @return [org.openhab.core.automation.Trigger]
           #
           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)
+            unless Conditions.state?(to)
+              conditions = Conditions::Generic.new(to: to)
+              to = nil
             end
+
+            type, config = case item
+                           when GroupItem::Members
+                             group_update(item: item, to: to)
+                           when Core::Things::Thing,
+                 Core::Things::ThingUID
+                             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
 
           private
 
           # @return [String] A thing status update trigger
           THING_UPDATE = "core.ThingStatusUpdateTrigger"
+          private_constant :THING_UPDATE
 
           # @return [String] An item state update trigger
           ITEM_STATE_UPDATE = "core.ItemStateUpdateTrigger"
+          private_constant :ITEM_STATE_UPDATE
 
           # @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 object to be attached to the trigger
-          # @return [org.openhab.core.automation.Trigger]
-          #
-          def range_trigger(item:, to:, attach:)
-            to, * = Conditions::Proc.range_procs(to)
-            proc_trigger(item: item, to: to, 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 object to be attached to the trigger
-          # @return [org.openhab.core.automation.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 a trigger for updates
-          #
-          # @param [Object] item Type of item [Group,Thing,Item] to create update trigger for
-          # @param [State] to state restriction on trigger
-          # @param [Object] attach object to be attached to the trigger
-          #
-          # @return [org.openhab.core.automation.Trigger]
-          #
-          def update_trigger(item:, to:, attach: nil, conditions: nil)
-            type, config = case item
-                           when GroupItem::Members
-                             group_update(item: item, to: to)
-                           when Core::Things::Thing,
-                                Core::Things::ThingUID
-                             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
+          private_constant :GROUP_STATE_UPDATE
 
           #
           # Create an update trigger for an item

data/lib/openhab/dsl/version.rb

@@ -4,6 +4,6 @@ module OpenHAB
   module DSL
     # Version of openHAB helper libraries
     # @return [String]
-    VERSION = "5.1.1"
+    VERSION = "5.2.0"
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: openhab-scripting
 version: !ruby/object:Gem::Version
-  version: 5.1.1
+  version: 5.2.0
 platform: ruby
 authors:
 - Brian O'Connell
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-04-23 00:00:00.000000000 Z
+date: 2023-05-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -527,8 +527,9 @@ files:
 - 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.rb
 - lib/openhab/dsl/rules/triggers/conditions/duration.rb
-- lib/openhab/dsl/rules/triggers/conditions/proc.rb
+- lib/openhab/dsl/rules/triggers/conditions/generic.rb
 - lib/openhab/dsl/rules/triggers/cron/cron.rb
 - lib/openhab/dsl/rules/triggers/cron/cron_handler.rb
 - lib/openhab/dsl/rules/triggers/trigger.rb

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

@@ -1,161 +0,0 @@
-# frozen_string_literal: true
-
-module OpenHAB
-  module DSL
-    module Rules
-      module Triggers
-        # @!visibility private
-        module Conditions
-          #
-          # This creates trigger conditions that work on procs
-          # @param [Proc] from Proc
-          # @param [Proc] to Proc
-          #
-          class Proc
-            #
-            # Converts supplied ranges to procs that check range
-            # @param [Array] ranges objects to convert to range proc if they are ranges
-            # @return [Array] of procs or supplied arguments if argument was not of type Range
-            #
-            def self.range_procs(*ranges)
-              ranges.map { |range| range.is_a?(Range) ? range_proc(range) : range }
-            end
-
-            #
-            # Create a range proc for the supplied range object
-            # @param [Range] range to build proc for
-            #
-            def self.range_proc(range)
-              logger.trace("Creating range proc for #{range}")
-              lambda do |val|
-                logger.trace("Range proc checking if #{val} is in #{range}")
-                range.cover? val
-              end
-            end
-
-            #
-            # Create an equality proc for the supplied range object
-            # @param [State] value to build proc for
-            #
-            def self.equality_proc(value)
-              logger.trace("Creating equality proc for #{value}")
-              lambda do |state|
-                logger.trace("Equality proc comparing #{value} against #{state}")
-                value == state
-              end
-            end
-
-            #
-            # Constructs a proc for the specific value type
-            #  if the value is a proc return the proc
-            #  if the value is a range create a range proc
-            #  if the value is nil, return nil
-            #  otherwise create an equality proc
-            # @param [Object] value to construct proc from
-            def self.from_value(value)
-              logger.trace("Creating proc for Value(#{value})")
-              return value if value.nil?
-              return value if value.is_a?(::Proc)
-              return range_proc(value) if value.is_a?(Range)
-
-              equality_proc(value)
-            end
-
-            #
-            # Create a new Proc Condition that executes only if procs return true
-            # @param [Proc] from Proc to check against from value
-            # @param [Proc] to Proc to check against to value
-            #
-            def initialize(from: nil, to: nil, command: nil)
-              @from = from
-              @to = to
-              @command = command
-            end
-
-            # Proc that doesn't check any fields
-            ANY = Proc.new.freeze # this needs to be defined _after_ initialize so its instance variables are set
-
-            #
-            # Process rule
-            # @param [Hash] inputs inputs from trigger
-            #
-            def process(mod:, inputs:) # rubocop:disable Lint/UnusedMethodArgument - mod is unused here but required
-              logger.trace("Checking #{inputs} against condition trigger #{self}")
-              yield if check_procs(inputs: inputs)
-            end
-
-            #
-            # Check if command condition match the proc
-            # @param [Hash] inputs from trigger must be supplied if state is not supplied
-            # @return [true/false] depending on if from is set and matches supplied conditions
-            #
-            def check_command(inputs: nil)
-              command = input_state(inputs, "command")
-              logger.trace "Checking command(#{@command}) against command(#{command})"
-              check_proc(proc: @command, value: command)
-            end
-
-            #
-            # Check if from condition match the proc
-            # @param [Hash] inputs from trigger must be supplied if state is not supplied
-            # @param [String] state if supplied proc will be passed state value for comparision
-            # @return [true/false] depending on if from is set and matches supplied conditions
-            #
-            def check_from(inputs: nil, state: nil)
-              state ||= input_state(inputs, "oldState")
-              logger.trace "Checking from(#{@from}) against state(#{state})"
-              check_proc(proc: @from, value: state)
-            end
-
-            #
-            # Check if to conditions match the proc
-            # @param [Hash] inputs from trigger must be supplied if state is not supplied
-            # @param [String] state if supplied proc will be passed state value for comparision
-            # @return [true/false] depending on if from is set and matches supplied conditions
-            #
-            def check_to(inputs: nil, state: nil)
-              state ||= input_state(inputs, "newState", "state")
-              logger.trace "Checking to(#{@to}) against state(#{state})"
-              check_proc(proc: @to, value: state)
-            end
-
-            # Describe the Proc Condition as a string
-            # @return [String] string representation of proc condition
-            #
-            def to_s
-              "From:(#{@from}) To:(#{@to}) Command:(#{@command})"
-            end
-
-            private
-
-            #
-            # Check all procs
-            # @param [Hash] inputs from event
-            # @return [true/false] true if all procs return true, false otherwise
-            def check_procs(inputs:)
-              check_from(inputs: inputs) && check_to(inputs: inputs) && check_command(inputs: inputs)
-            end
-
-            # Check if a field matches the proc condition
-            # @param [Proc] proc to call
-            # @param [Hash] value to check
-            # @return [true,false] true if proc is nil or proc.call returns true, false otherwise
-            def check_proc(proc:, value:)
-              return true if proc.nil? || proc.call(value)
-
-              logger.trace("Skipped execution of rule because value #{value} evaluated false for (#{proc})")
-              false
-            end
-
-            # Get the first field from supplied fields in inputs
-            # @param [Hash] inputs containing fields
-            # @param [Array] fields array of fields to extract from inputs, first one found is returned
-            def input_state(inputs, *fields)
-              fields.map { |f| inputs[f] }.compact.first
-            end
-          end
-        end
-      end
-    end
-  end
-end