openhab-scripting 4.29.0 → 4.30.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 346933e8c00b9208f18ce61d4a87911cdc315a7b7ee1698aec1977dc47ba9bea
-  data.tar.gz: 5a94e6d5a1d43a4fd3e6586bd70a9f3286918bee1c300fe490d2460dbdce3494
+  metadata.gz: a4e5de50bc22188eb5350aa71f00738703afab2e75703c9f5c2f4ffce54c49dc
+  data.tar.gz: e42484957fcea08aaf5d397af1ec5012b5595bd893eacca7bbc2db3149a1707b
 SHA512:
-  metadata.gz: dcd2f7d6aa7b11074c059296b61b0fa22b691184915afe227ecf41d865690b6a81c8ea431c3b83407f05520aedca8238be4636f8da62217a0caf090d63bd8488
-  data.tar.gz: 1614e96cd679ebab6dfe811e7818e77e9e512603b126223f6a870f7b6550a2101cb86fe79f9856fe6559cc926cecf212afe15eb8a50892863c208b32d00f6386
+  metadata.gz: af5435c5804d2a58f1e8cf84647ee1813c80c958e9b1c3c6794d6879adeebd71ac6955454ad424522916375d7314719312b561d7b2a718ad43b48e76edd2801c
+  data.tar.gz: 2f3e46d17e305d1169980fdf2aa5ae8f5673e4730d73d2d10dbb445582642086522d3ab43e9bae5a411637ec1e787d465431423fb307a04ed09178be5953c25a

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

@@ -32,6 +32,13 @@ module OpenHAB
             group.get_members.to_a
           end
 
+          # Name of the group
+          #
+          # @return [String]
+          def name
+            group.name
+          end
+
           # Send a command to each member of the group
           #
           # @return [GroupMembers] +self+

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

@@ -35,7 +35,7 @@ module OpenHAB
         # Explicit conversion to array
         # @return [Array]
         def to_a
-          $ir.items.grep_v(org.openhab.core.items.GroupItem) # rubocop:disable Style/GlobalVars
+          $ir.items.to_a # rubocop:disable Style/GlobalVars
         end
       end
 

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

@@ -10,7 +10,7 @@ require_relative 'triggers/command'
 require_relative 'triggers/updated'
 require_relative 'triggers/generic'
 require_relative 'triggers/watch'
-require_relative 'triggers/conditions/none'
+require_relative 'triggers/conditions/proc'
 require_relative 'guard'
 require 'openhab/core/entity_lookup'
 require 'openhab/dsl/between'
@@ -87,7 +87,7 @@ module OpenHAB
         #
         def initialize(rule_name, caller_binding)
           @triggers = []
-          @trigger_conditions = Hash.new(OpenHAB::DSL::Rules::Triggers::Conditions::None.instance)
+          @trigger_conditions = Hash.new(OpenHAB::DSL::Rules::Triggers::Conditions::Proc::ANY)
           @attachments = {}
           @caller = caller_binding.eval 'self'
           name(rule_name)

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

@@ -2,7 +2,7 @@
 
 require 'openhab/log/logger'
 require_relative 'conditions/duration'
-require_relative 'conditions/range'
+require_relative 'conditions/proc'
 
 module OpenHAB
   module DSL
@@ -74,6 +74,8 @@ module OpenHAB
             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)
           end
@@ -91,10 +93,12 @@ module OpenHAB
         # @return [Trigger] OpenHAB trigger
         #
         def changed_wait(item, duration:, to: nil, from: nil, attach: nil)
-          trigger = create_changed_trigger(item, nil, nil, attach)
-          logger.trace("Creating Changed Wait Change Trigger for #{item}")
-          @trigger_conditions[trigger.id] = Conditions::Duration.new(to: to, from: from, duration: duration)
-          trigger
+          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)
+          end
         end
 
         #
@@ -106,11 +110,26 @@ module OpenHAB
         # @return [Trigger] OpenHAB trigger
         #
         def create_changed_range_trigger(item, from:, to:, attach:)
-          # swap range w/ nil if from or to is a range
-          from_range, from = from, from_range if from.is_a? Range
-          to_range, to = to, to_range if to.is_a? Range
+          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 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::Range.new(to: to_range, from: from_range)
+          @trigger_conditions[trigger.id] = Conditions::Proc.new(to: to_proc, from: from_proc)
           trigger
         end
 

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

@@ -23,12 +23,20 @@ module OpenHAB
           #    timer&.is_active
           #  end
           # end
-
           class Duration
+            #
+            # Create a new duration condition
+            # @param [Object] to optional condition on to state
+            # @param [Object] from optional condition on from state
+            # @param [Duration] Duration to state must stay at specific value before triggering
+            #
             def initialize(to:, from:, duration:)
-              @to = to
-              @from = from
+              to = Conditions::Proc.from_value(to)
+              from = Conditions::Proc.from_value(from)
+              @conditions = Conditions::Proc.new(to: to, from: from)
               @duration = duration
+              logger.trace "Created Duration Condition To(#{to}) From(#{from}) "\
+                           "Conditions(#{@conditions}) Duration(#{@duration})"
             end
 
             # Process rule
@@ -56,15 +64,7 @@ module OpenHAB
             #
             def check_trigger_guards(inputs)
               new_state, old_state = retrieve_states(inputs)
-              if check_from(old_state)
-                return true if check_to(new_state)
-
-                logger.trace("Skipped execution of rule because to state #{new_state}"\
-                             " does not equal specified state(#{@to})")
-              else
-                logger.trace("Skipped execution of rule because old state #{old_state}"\
-                             " does not equal specified state(#{@from})")
-              end
+              @conditions.check_from(state: old_state) && @conditions.check_to(state: new_state)
             end
 
             #
@@ -76,8 +76,8 @@ module OpenHAB
             # @return [Array] An array of the values for [newState, oldState] or [newStatus, oldStatus]
             #
             def retrieve_states(inputs)
-              old_state = inputs['oldState'] || thing_status_to_sym(inputs['oldStatus'])
               new_state = inputs['newState'] || thing_status_to_sym(inputs['newStatus'])
+              old_state = inputs['oldState'] || thing_status_to_sym(inputs['oldStatus'])
 
               [new_state, old_state]
             end
@@ -93,32 +93,6 @@ module OpenHAB
               status&.to_s&.downcase&.to_sym
             end
 
-            #
-            # Check the from state against the trigger delay
-            #
-            # @param [Item State] state from state to check
-            #
-            # @return [Boolean] true if no from state is defined or defined state equals supplied state
-            #
-            def check_from(state)
-              return @from.include?(state) if @from.is_a?(::Range)
-
-              @from.nil? || @from == state
-            end
-
-            #
-            # Check the to state against the trigger delay
-            #
-            # @param [Item State] state to-state to check
-            #
-            # @return [Boolean] true if no to state is defined or defined state equals supplied state
-            #
-            def check_to(state)
-              return @to.include?(state) if @to.is_a?(::Range)
-
-              @to.nil? || @to == state
-            end
-
             #
             # Process any matching trigger delays
             #

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

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+require 'openhab/log/logger'
+
+module OpenHAB
+  module DSL
+    module Rules
+      module Triggers
+        #
+        # Module for conditions for triggers
+        #
+        module Conditions
+          include OpenHAB::Log
+
+          #
+          # This creates trigger conditions that work on procs
+          # @param [Proc] from Proc
+          # @param [Proc] to Proc
+          #
+          class Proc
+            include OpenHAB::Log
+
+            # Proc that doesn't check any fields
+            ANY = Proc.new.freeze
+
+            #
+            # 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 |state|
+                logger.trace("Range proc checking if #{state} is in  #{range}")
+                range.include? state
+              end
+            end
+
+            #
+            # Create a range proc for the supplied range object
+            # @param [Range] range 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)
+              @from = from
+              @to = to
+            end
+
+            #
+            # 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_from(inputs: inputs) && check_to(inputs: inputs)
+            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, state: 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, state: state)
+            end
+
+            # Describe the Proc Condition as a string
+            # @return [String] string representation of proc condition
+            #
+            def to_s
+              "From:(#{@from}) To:(#{@to})"
+            end
+
+            private
+
+            # Check if a field matches the proc condition
+            # @param [Proc] proc to call
+            # @param [Hash] inputs containing fields
+            # @param [Array] fields array of fields to extract from inputs, first one found is passed to proc
+            # @return [true,false] true if proc is nil or proc.call returns true, false otherwise
+            def check_proc(proc:, state:)
+              return true if proc.nil? || proc.call(state)
+
+              logger.trace("Skipped execution of rule because state #{state} evalulated 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

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

@@ -42,10 +42,10 @@ module OpenHAB
         # @return [Trigger] OpenHAB triggers
         #
         def update_trigger(item:, to:, attach:)
-          if to.is_a? Range
-            create_update_range_trigger(item: item, to: to, attach: attach)
-          else
-            create_update_trigger(item: item, to: to, attach: 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)
           end
         end
 
@@ -57,9 +57,21 @@ module OpenHAB
         # @return [Trigger] OpenHAB trigger
         #
         def create_update_range_trigger(item:, to:, attach:)
-          trigger = create_update_trigger(item: item, to: nil, attach: attach)
-          @trigger_conditions[trigger.id] = Conditions::Range.new(to: to, from: nil)
-          trigger
+          to, * = Conditions::Proc.range_procs(to)
+          create_update_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 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)
+          end
         end
 
         #

data/lib/openhab/version.rb

@@ -5,5 +5,5 @@
 #
 module OpenHAB
   # @return [String] Version of OpenHAB helper libraries
-  VERSION = '4.29.0'
+  VERSION = '4.30.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: openhab-scripting
 version: !ruby/object:Gem::Version
-  version: 4.29.0
+  version: 4.30.0
 platform: ruby
 authors:
 - Brian O'Connell
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2022-01-17 00:00:00.000000000 Z
+date: 2022-01-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -107,8 +107,7 @@ files:
 - lib/openhab/dsl/rules/triggers/channel.rb
 - lib/openhab/dsl/rules/triggers/command.rb
 - lib/openhab/dsl/rules/triggers/conditions/duration.rb
-- lib/openhab/dsl/rules/triggers/conditions/none.rb
-- lib/openhab/dsl/rules/triggers/conditions/range.rb
+- lib/openhab/dsl/rules/triggers/conditions/proc.rb
 - lib/openhab/dsl/rules/triggers/cron.rb
 - lib/openhab/dsl/rules/triggers/generic.rb
 - lib/openhab/dsl/rules/triggers/trigger.rb

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

@@ -1,32 +0,0 @@
-# frozen_string_literal: true
-
-require 'openhab/log/logger'
-require 'singleton'
-
-module OpenHAB
-  module DSL
-    module Rules
-      module Triggers
-        #
-        # Module for conditions for triggers
-        #
-        module Conditions
-          include OpenHAB::Log
-          #
-          # this is a no-op condition which simply executes the provided block
-          #
-          class None
-            include Singleton
-
-            # Process rule
-            # @param [Hash] inputs inputs from trigger
-            #
-            def process(*)
-              yield
-            end
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,74 +0,0 @@
-# frozen_string_literal: true
-
-require 'openhab/log/logger'
-
-module OpenHAB
-  module DSL
-    module Rules
-      module Triggers
-        #
-        # Module for conditions for triggers
-        #
-        module Conditions
-          include OpenHAB::Log
-
-          #
-          # This creates trigger conditions that work on ranges
-          # @param [Range:] From range
-          # @param [To:] To range
-          #
-          class Range
-            def initialize(from: nil, to: nil)
-              @from = from
-              @to = to
-            end
-
-            #
-            # 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_from(inputs: inputs) && check_to(inputs: inputs)
-            end
-
-            #
-            # Check if from condition match the inputs
-            # @param [Hash] inputs inputs from trigger
-            # @return [true/false] depending on if from is set and matches supplied conditions
-            #
-            def check_from(inputs:)
-              old_state = inputs['oldState']
-              return true if @from.nil? || @from.include?(old_state)
-
-              logger.trace("Skipped execution of rule because old state #{old_state}"\
-                           " does not equal specified range(#{@from})")
-              false
-            end
-
-            #
-            # Check if to conditions match the inputs
-            # @param [Hash] inputs inputs from trigger
-            # @return [true/false] depending on if from is set and matches supplied conditions
-            #
-            def check_to(inputs:)
-              new_state = inputs['newState'] || inputs['state'] # Get state for changed or update
-              return true if @to.nil? || @to.include?(new_state)
-
-              logger.trace("Skipped execution of rule because new state #{new_state}"\
-                           " does not equal specified range(#{@to})")
-              false
-            end
-
-            # Describe the Range Condition as a string
-            # @return [String] string representation of range condition
-            #
-            def to_s
-              "From:(#{@from}) To:(#{@to})"
-            end
-          end
-        end
-      end
-    end
-  end
-end