openhab-scripting 4.47.0 → 5.0.0

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

@@ -1,134 +1,71 @@
 # frozen_string_literal: true
 
-require 'openhab/dsl/rules/property'
-require 'openhab/log/logger'
-
 module OpenHAB
   module DSL
     module Rules
       #
-      # Guards for rules
+      # Guard that can prevent execution of a rule if not satisfied
       #
-      module Guard
-        include OpenHAB::DSL::Rules::Property
-
-        prop_array(:only_if) do |item|
-          unless item.is_a?(Proc) || [item].flatten.all? { |it| it.respond_to?(:truthy?) }
-            raise ArgumentError, "Object passed to only_if must respond_to 'truthy?'"
-          end
+      # @!visibility private
+      class Guard
+        #
+        # Create a new Guard
+        #
+        # @param [Array<Proc>] only_if Array of Procs to use as guard
+        # @param [Array<Proc>] not_if Array of Procs to use as guard
+        #
+        def initialize(run_context:, only_if: nil, not_if: nil)
+          @run_context = run_context
+          @only_if = only_if
+          @not_if = not_if
         end
 
-        prop_array(:not_if) do |item|
-          unless item.is_a?(Proc) || [item].flatten.all? { |it| it.respond_to?(:truthy?) }
-            raise ArgumentError, "Object passed to not_if must respond_to 'truthy?'"
-          end
+        #
+        # Convert the guard into a string
+        #
+        # @return [String] describing the only_of and not_if guards
+        #
+        def to_s
+          "only_if: #{@only_if}, not_if: #{@not_if}"
         end
 
         #
-        # Guard that can prevent execute of a rule if not satisfied
+        # Checks if a guard should run
         #
-        class Guard
-          include OpenHAB::Log
-
-          #
-          # Create a new Guard
-          #
-          # @param [Object] only_if Item or Proc to use as guard
-          # @param [Object] not_if Item or Proc to use as guard
-          #
-          def initialize(run_context:, only_if: nil, not_if: nil)
-            @run_context = run_context
-            @only_if = only_if
-            @not_if = not_if
-          end
-
-          #
-          # Convert the guard into a string
-          #
-          # @return [String] describing the only_of and not_if guards
-          #
-          def to_s
-            "only_if: #{@only_if}, not_if: #{@not_if}"
-          end
-
-          #
-          # Checks if a guard should run
-          #
-          # @param [OpenHAB Trigger Event] event OpenHAB Trigger Event
-          #
-          # @return [Boolean] True if guard is satisfied, false otherwise
-          #
-          def should_run?(event)
-            logger.trace("Checking guards #{self}")
-            check(@only_if, :check_type => :only_if,
-                            :event => event) && check(@not_if, :check_type => :not_if, :event => event)
-          end
-
-          private
-
-          #
-          # Check if guard is satisfied
-          #
-          # @param [Array] conditions to check
-          # @param [Symbol] check_type type of check to perform (:only_if or :not_if)
-          # @param [Event] event OpenHAB event to see if it satisfies the guard
-          #
-          # @return [Boolean] True if guard is satisfied, false otherwise
-          #
-          def check(conditions, check_type:, event:)
-            return true if conditions.nil? || conditions.empty?
-
-            procs, items = conditions.flatten.partition { |condition| condition.is_a? Proc }
-            logger.trace("Procs: #{procs} Items: #{items}")
-
-            items.each { |item| logger.trace { "#{item} truthy? #{item.truthy?}" } }
+        # @param [Object] event openHAB Trigger Event
+        #
+        # @return [true,false] True if guard is satisfied, false otherwise
+        #
+        def should_run?(event)
+          logger.trace("Checking guards #{self}")
+          return false unless check_only_if(event)
+          return false unless check_not_if(event)
 
-            process_check(check_type: check_type, event: event, items: items, procs: procs)
-          end
+          true
+        end
 
-          #
-          # Execute the guard check
-          #
-          # @param [Symbol] check_type :only_if or :not_if to check
-          # @param [OpenHAB Event] event event to check if meets guard
-          # @param [Array<Item>] items to check if satisfy criteria
-          # @param [Array] procs to check if satisfy criteria
-          #
-          # @return [Boolean] True if criteria are satisfied, false otherwise
-          #
-          def process_check(check_type:, event:, items:, procs:)
-            case check_type
-            when :only_if then process_only_if(event, items, procs)
-            when :not_if then  process_not_if(event, items, procs)
-            else raise ArgumentError, "Unexpected check type: #{check_type}"
-            end
-          end
+        private
 
-          #
-          # Check not_if guard
-          #
-          # @param [OpenHAB Event] event to check if meets guard
-          # @param [Array<Item>] items to check if satisfy criteria
-          # @param [Array] procs to check if satisfy criteria
-          #
-          # @return [Boolean] True if criteria are satisfied, false otherwise
-          #
-          def process_not_if(event, items, procs)
-            items.flatten.none?(&:truthy?) && procs.none? { |proc| @run_context.instance_exec(event, &proc) }
-          end
+        #
+        # Check not_if guards
+        #
+        # @param [Object] event to check if meets guard
+        #
+        # @return [true,false] True if criteria are satisfied, false otherwise
+        #
+        def check_not_if(event)
+          @not_if.nil? || @not_if.none? { |proc| @run_context.instance_exec(event, &proc) }
+        end
 
-          #
-          # Check only_if guard
-          #
-          # @param [OpenHAB Event] event to check if meets guard
-          # @param [Array<Item>] items to check if satisfy criteria
-          # @param [Array] procs to check if satisfy criteria
-          #
-          # @return [Boolean] True if criteria are satisfied, false otherwise
-          #
-          def process_only_if(event, items, procs)
-            items.flatten.all?(&:truthy?) && procs.all? { |proc| @run_context.instance_exec(event, &proc) }
-          end
+        #
+        # Check only_if guards
+        #
+        # @param [Object] event to check if meets guard
+        #
+        # @return [true,false] True if criteria are satisfied, false otherwise
+        #
+        def check_only_if(event)
+          @only_if.nil? || @only_if.all? { |proc| @run_context.instance_exec(event, &proc) }
         end
       end
     end

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

@@ -1,19 +1,24 @@
 # frozen_string_literal: true
 
+require_relative "triggers/cron/cron"
+
 module OpenHAB
   module DSL
     module Rules
       # Contains helper methods for inferring a rule name from its triggers
+      # @!visibility private
       module NameInference
         # Trigger Type UIDs that we know how to generate a name for
         KNOWN_TRIGGER_TYPES = [
-          'core.ChannelEventTrigger',
-          'core.GroupCommandTrigger',
-          'core.GroupStateChangeTrigger',
-          'core.GroupStateUpdateTrigger',
-          'core.ItemCommandTrigger',
-          'core.ItemStateChangeTrigger',
-          'core.ItemStateUpdateTrigger',
+          "core.ChannelEventTrigger",
+          "core.GenericEventTrigger",
+          "core.GroupCommandTrigger",
+          "core.GroupStateChangeTrigger",
+          "core.GroupStateUpdateTrigger",
+          "core.ItemCommandTrigger",
+          "core.ItemStateChangeTrigger",
+          "core.ItemStateUpdateTrigger",
+          "core.SystemStartlevelTrigger",
           Triggers::Cron::CRON_TRIGGER_MODULE_ID
         ].freeze
         private_constant :KNOWN_TRIGGER_TYPES
@@ -26,13 +31,13 @@ module OpenHAB
           end
 
           # formulate a readable rule name such as "TestSwitch received command ON" if possible
-          def infer_rule_name(config) # rubocop:disable Metrics
+          def infer_rule_name(config)
             known_triggers, unknown_triggers = config.triggers.partition do |t|
               KNOWN_TRIGGER_TYPES.include?(t.type_uid)
             end
             return nil unless unknown_triggers.empty?
 
-            cron_triggers = known_triggers.select { |t| t.type_uid == 'jsr223.jruby.CronTrigger' }
+            cron_triggers = known_triggers.select { |t| t.type_uid == "jsr223.jruby.CronTrigger" }
             ruby_every_triggers = config.ruby_triggers.select { |t| t.first == :every }
 
             # makes sure there aren't any true cron triggers cause we can't format them
@@ -45,7 +50,7 @@ module OpenHAB
           private
 
           # formulate a readable rule name from a single trigger if possible
-          def infer_rule_name_from_trigger(trigger, items, kwargs)
+          def infer_rule_name_from_trigger(trigger, items = nil, kwargs = {})
             case trigger
             when :every
               infer_rule_name_from_every_trigger(items, **kwargs)
@@ -53,11 +58,19 @@ module OpenHAB
               infer_rule_name_from_channel_trigger(items, **kwargs)
             when :changed, :updated, :received_command
               infer_rule_name_from_item_trigger(trigger, items, kwargs)
+            when :channel_linked, :channel_unlinked
+              infer_rule_name_from_channel_link_trigger(trigger)
+            when :item_added, :item_removed, :item_updated
+              infer_rule_name_from_item_registry_trigger(trigger)
+            when :thing_added, :thing_removed, :thing_updated
+              infer_rule_name_from_thing_trigger(trigger)
+            when :on_start
+              infer_rule_name_from_on_start_trigger(items)
             end
           end
 
           # formulate a readable rule name from an item-type trigger
-          def infer_rule_name_from_item_trigger(trigger, items, kwargs) # rubocop:disable Metrics
+          def infer_rule_name_from_item_trigger(trigger, items, kwargs)
             kwargs.delete(:command) if kwargs[:command] == [nil]
             return unless items.length <= 3 &&
                           (kwargs.keys - %i[from to command duration]).empty?
@@ -68,15 +81,15 @@ module OpenHAB
               v.is_a?(Proc) || v.is_a?(Enumerable)
             end
 
-            trigger_name = trigger.to_s.tr('_', ' ')
+            trigger_name = trigger.to_s.tr("_", " ")
             item_names = items.map do |item|
-              if item.is_a?(GroupItem::GroupMembers)
+              if item.is_a?(GroupItem::Members)
                 "#{item.group.name}.members"
               else
                 item.name
               end
             end
-            name = "#{format_beginning_of_sentence_array(item_names)} #{trigger_name}"
+            name = "#{format_array(item_names)} #{trigger_name}"
 
             name += " from #{format_inspected_array(kwargs[:from])}" if kwargs[:from]
             name += " to #{format_inspected_array(kwargs[:to])}" if kwargs[:to]
@@ -95,20 +108,48 @@ module OpenHAB
           # formulate a readable rule name from a channel trigger
           def infer_rule_name_from_channel_trigger(channels, triggers:)
             triggers = [] if triggers == [nil]
-            name = "#{format_beginning_of_sentence_array(channels)} triggered"
+            name = "#{format_array(channels)} triggered"
             name += " #{format_inspected_array(triggers)}" unless triggers.empty?
             name
           end
 
-          # format an array of words that will be the beginning of a sentence
-          def format_beginning_of_sentence_array(array)
-            result = format_array(array)
-            if array.length > 2
-              result = result.dup
-              result[0] = 'A'
-              result.freeze
-            end
-            result
+          # formulate a readable rule name from a channel link trigger
+          def infer_rule_name_from_channel_link_trigger(trigger)
+            (trigger == :channel_linked) ? "Channel linked to item" : "Channel unlinked from item"
+          end
+
+          # formulate a readable rule name from an item added/updated/remove trigger
+          def infer_rule_name_from_item_registry_trigger(trigger)
+            {
+              item_added: "Item added",
+              item_updated: "Item updated",
+              item_removed: "Item removed"
+            }[trigger]
+          end
+
+          # formulate a readable rule name from a thing added/updated/remove trigger
+          def infer_rule_name_from_thing_trigger(trigger)
+            {
+              thing_added: "Thing Added",
+              thing_updated: "Thing updated",
+              thing_removed: "Thing removed"
+            }[trigger]
+          end
+
+          # formulate a readable rule name from an on_start trigger
+          def infer_rule_name_from_on_start_trigger(levels)
+            levels = levels.map { |level| "#{level} (#{start_level_description(level)})" }
+            levels = format_array(levels)
+            "System Start Level reached #{levels}"
+          end
+
+          def start_level_description(level)
+            klass = org.openhab.core.service.StartLevelService.java_class
+            start_level_type = klass.declared_field("STARTLEVEL_OSGI").type
+            klass.declared_fields
+                 .select { |field| field.type == start_level_type && field.name.start_with?("STARTLEVEL_") }
+                 .find { |field| field.get_int(klass) == level }
+                 .name.split("_", 2).last.downcase
           end
 
           # format an array of items that need to be inspected individually
@@ -124,7 +165,7 @@ module OpenHAB
             return array[0] if array.length == 1
             return "#{array[0]} or #{array[1]}" if array.length == 2
 
-            "any of #{array.join(', ')}"
+            "#{array[0..-2].join(", ")}, or #{array[-1]}"
           end
         end
       end

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

@@ -1,101 +1,74 @@
 # frozen_string_literal: true
 
-require 'openhab/log/logger'
-
 module OpenHAB
   module DSL
     module Rules
       #
       # Provides methods to support DSL properties
       #
+      # @visibility private
       module Property
-        include OpenHAB::Log
-
         #
-        # Extend the calling object with the property methods
+        # Dynamically creates a property that acts as an accessor with no arguments
+        # and a setter with any number of arguments or a block.
         #
-        # @param [Object] base object to extend
+        # @param [String] name of the property
         #
-        #
-        def self.included(base)
-          base.extend PropertyMethods
+        def prop(name)
+          # rubocop rules are disabled because this method is dynamically defined on the calling
+          #   object making calls to other methods in this module impossible, or if done on methods
+          #   in this module than instance variable belong to the module not the calling class
+          define_method(name) do |*args, &block|
+            if args.empty? && block.nil? == true
+              instance_variable_get("@#{name}")
+            else
+              logger.trace("Property '#{name}' called with args(#{args}) and block(#{block})")
+              if args.length == 1
+                instance_variable_set("@#{name}", args.first)
+              elsif args.length > 1
+                instance_variable_set("@#{name}", args)
+              elsif block
+                instance_variable_set("@#{name}", block)
+              end
+            end
+          end
         end
 
         #
-        # Methods that support creating properties in the DSL
+        # Dynamically creates a property array that acts as an accessor with no arguments
+        # and pushes any number of arguments or a block onto the property array
+        # You can provide a block to this method which can be used to check if the provided value is acceptable.
+        #
+        # @param [String] name of the property
+        # @param [String] array_name name of the array to use, defaults to name of property
+        # @param [Class] wrapper object to put around elements added to the array
         #
-        module PropertyMethods
-          #
-          # Dynamically creates a property that acts and an accessor with no arguments
-          # and a setter with any number of arguments or a block.
-          #
-          # @param [String] name of the property
-          #
-          #
-          # rubocop:disable Metrics/MethodLength
-          # rubocop:disable Metrics/AbcSize
-          # rubocop:disable Metrics/CyclomaticComplexity
-          # rubocop:disable Metrics/PerceivedComplexity
-          def prop(name)
-            # rubocop rules are disabled because this method is dynamically defined on the calling
-            #   object making calls to other methods in this module impossible, or if done on methods
-            #   in this module than instance variable belong to the module not the calling class
-            define_method(name) do |*args, &block|
-              if args.length.zero? && block.nil? == true
-                instance_variable_get("@#{name}")
-              else
-                logger.trace("Property '#{name}' called with args(#{args}) and block(#{block})")
-                if args.length == 1
-                  instance_variable_set("@#{name}", args.first)
-                elsif args.length > 1
-                  instance_variable_set("@#{name}", args)
-                elsif block
-                  instance_variable_set("@#{name}", block)
-                end
+        def prop_array(name, array_name: nil, wrapper: nil)
+          define_method(name) do |*args, &block|
+            array_name ||= name
+            if args.empty? && block.nil? == true
+              instance_variable_get("@#{array_name}")
+            else
+              logger.trace("Property '#{name}' called with args(#{args}) and block(#{block})")
+              if args.length == 1
+                insert = args.first
+              elsif args.length > 1
+                insert = args
+              elsif block
+                insert = block
               end
+              yield insert if block_given?
+              insert = wrapper.new(insert) if wrapper
+              instance_variable_set("@#{array_name}", (instance_variable_get("@#{array_name}") || []) << insert)
             end
           end
 
-          #
-          # Dynamically creates a property array acts and an accessor with no arguments
-          # and a pushes any number of arguments or a block onto they property array
-          # You can provide a block to this method which can be used to check if the provided value is acceptable.
-          #
-          # @param [String] name of the property
-          # @param [String] array_name name of the array to use, defaults to name of property
-          # @param [Class] wrapper object to put around elements added to the array
-          #
-          def prop_array(name, array_name: nil, wrapper: nil)
-            define_method(name) do |*args, &block|
-              array_name ||= name
-              if args.length.zero? && block.nil? == true
-                instance_variable_get("@#{array_name}")
-              else
-                logger.trace("Property '#{name}' called with args(#{args}) and block(#{block})")
-                if args.length == 1
-                  insert = args.first
-                elsif args.length > 1
-                  insert = args
-                elsif block
-                  insert = block
-                end
-                yield insert if block_given?
-                insert = wrapper.new(insert) if wrapper
-                instance_variable_set("@#{array_name}", (instance_variable_get("@#{array_name}") || []) << insert)
-              end
-            end
-
-            return unless array_name
+          return unless array_name
 
-            define_method(array_name) do
-              instance_variable_get("@#{array_name}")
-            end
+          define_method(array_name) do
+            instance_variable_get("@#{array_name}")
           end
         end
-        # rubocop:enable Metrics/MethodLength
-        # rubocop:enable Metrics/AbcSize
-        # rubocop:enable Metrics/CyclomaticComplexity
-        # rubocop:enable Metrics/PerceivedComplexity
       end
     end
   end

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

@@ -1,26 +1,19 @@
 # frozen_string_literal: true
 
-require 'forwardable'
-require 'java'
-require 'securerandom'
-require 'openhab/log/logger'
-require_relative 'triggers/conditions/proc'
+require "forwardable"
+
+require "securerandom"
+
+require_relative "triggers/conditions/proc"
 
 module OpenHAB
   module DSL
-    #
-    # Creates and manages OpenHAB Rules
-    #
     module Rules
       #
-      # Rule configuration for OpenHAB Rules engine
+      # Rule configuration for openHAB Rules engine
       #
+      # @!visibility private
       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
 
@@ -35,7 +28,7 @@ module OpenHAB
         #
         def initialize
           @triggers = []
-          @trigger_conditions = Hash.new(OpenHAB::DSL::Rules::Triggers::Conditions::Proc::ANY)
+          @trigger_conditions = Hash.new(Triggers::Conditions::Proc::ANY)
           @attachments = {}
         end
 
@@ -46,12 +39,12 @@ module OpenHAB
         # @param [Map] config map describing trigger configuration
         # @param [Object] attach object to be attached to the trigger
         #
-        # @return [Trigger] OpenHAB trigger
+        # @return [org.openhab.core.automation.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})")
+            logger.trace("Appending trigger (#{trigger.inspect}) attach (#{attach}) conditions(#{conditions})")
             @triggers << trigger
             @attachments[trigger.id] = attach if attach
             @trigger_conditions[trigger.id] = conditions if conditions
@@ -64,15 +57,15 @@ module OpenHAB
         # @param [String] type of trigger
         # @param [Map] config map
         #
-        # @return [OpenHAB Trigger] configured by type and supplied config
+        # @return [org.openhab.core.automation.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
+          org.openhab.core.automation.util.TriggerBuilder.create
+             .with_id(uuid)
+             .with_type_uid(type)
+             .with_configuration(org.openhab.core.config.core.Configuration.new(config))
+             .build
         end
 
         #
@@ -90,10 +83,12 @@ module OpenHAB
         # @return [String] details of the config object
         #
         def inspect
-          "Triggers: (#{triggers}) " \
-            "Trigger Conditions: #{trigger_conditions} " \
-            "Trigger UIDs: #{triggers.map(&:id).join(', ')}" \
-            "Attachments: #{attachments} "
+          <<~TEXT.tr("\n", " ")
+            #<RuleTriggers #{triggers.inspect}
+            Conditions: #{trigger_conditions.inspect}
+            UIDs: #{triggers.map(&:id).inspect}
+            Attachments: #{attachments.inspect}>
+          TEXT
         end
       end
     end