openhab-scripting 2.16.0 → 2.17.0

data/lib/openhab/core/dsl/rule/guard.rb

@@ -1,136 +0,0 @@
-# frozen_string_literal: true
-
-require 'core/dsl/property'
-require 'core/log'
-
-module OpenHAB
-  module Core
-    module DSL
-      module Rule
-        #
-        # Guards for rules
-        #
-        module Guard
-          include DSLProperty
-
-          prop_array(:only_if) do |item|
-            unless item.is_a?(Proc) || item.respond_to?(:truthy?)
-              raise ArgumentError, "Object passed to only_if must respond_to 'truthy?'"
-            end
-          end
-
-          prop_array(:not_if) do |item|
-            unless item.is_a?(Proc) || item.respond_to?(:truthy?)
-              raise ArgumentError, "Object passed to not_if must respond_to 'truthy?'"
-            end
-          end
-
-          #
-          # Guard that can prevent execute of a rule if not satisfied
-          #
-          class Guard
-            include Logging
-
-            #
-            # 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(only_if: nil, not_if: nil)
-              @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?}") }
-
-              process_check(check_type: check_type, event: event, items: items, procs: procs)
-            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
-
-            #
-            # Check not_if guard
-            #
-            # @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_not_if(event, items, procs)
-              items.none?(&:truthy?) && procs.none? { |proc| proc.call(event) }
-            end
-
-            #
-            # Check only_if guard
-            #
-            # @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_only_if(event, items, procs)
-              items.all?(&:truthy?) && procs.all? { |proc| proc.call(event) }
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/openhab/core/dsl/rule/rule.rb

@@ -1,117 +0,0 @@
-# frozen_string_literal: true
-
-require 'core/dsl/rule/rule_config'
-require 'core/dsl/rule/automation_rule'
-require 'core/dsl/rule/guard'
-
-module OpenHAB
-  module Core
-    #
-    # Contains code to create an OpenHAB DSL
-    #
-    module DSL
-      #
-      # Creates and manages OpenHAB Rules
-      #
-      module Rule
-        #
-        # Create a new rule
-        #
-        # @param [String] rule_name <description>
-        # @yield [] Block executed in context of a RuleConfig
-        #
-        #
-        def rule(rule_name, &block)
-          config = RuleConfig.new(rule_name, block.binding)
-          config.instance_eval(&block)
-          config.guard = Guard::Guard.new(only_if: config.only_if, not_if: config.not_if)
-          logger.trace { config.inspect }
-          process_rule_config(config)
-        end
-
-        #
-        # Create a logger where name includes rule name if name is set
-        #
-        # @return [Logging::Logger] Logger with name that appended with rule name if rule name is set
-        #
-        def logger
-          if name
-            Logging.logger(name.chomp.gsub(/\s+/, '_'))
-          else
-            super
-          end
-        end
-
-        private
-
-        #
-        # Process a rule based on the supplied configuration
-        #
-        # @param [RuleConfig] config for rule
-        #
-        #
-        def process_rule_config(config)
-          return unless create_rule?(config)
-
-          rule = AutomationRule.new(config: config)
-          add_rule(rule)
-          rule.execute if config.on_start?
-        end
-
-        #
-        # Should a rule be created based on rule configuration
-        #
-        # @param [RuleConfig] config to check
-        #
-        # @return [Boolean] true if it should be created, false otherwise
-        #
-        def create_rule?(config)
-          if !triggers?(config)
-            logger.warn "Rule '#{config.name}' has no triggers, not creating rule"
-          elsif !execution_blocks?(config)
-            logger.warn "Rule '#{config.name}' has no execution blocks, not creating rule"
-          elsif !config.enabled
-            logger.debug "Rule '#{config.name}' marked as disabled, not creating rule."
-          else
-            return true
-          end
-          false
-        end
-
-        #
-        # Check if the rule has any triggers
-        #
-        # @param [RuleConfig] config to check for triggers
-        #
-        # @return [Boolean] True if rule has triggers, false otherwise
-        #
-        def triggers?(config)
-          config.on_start? || config.triggers.length.positive?
-        end
-
-        #
-        # Check if the rule has any execution blocks
-        #
-        # @param [RuleConfig] config to check for triggers
-        #
-        # @return [Boolean] True if rule has execution blocks, false otherwise
-        #
-        def execution_blocks?(config)
-          (config.run || []).length.positive?
-        end
-
-        #
-        # Add a rule to the automation managed
-        #
-        # @param [Java::OrgOpenhabCoreAutomationModuleScriptRulesupportSharedSimple::SimpleRule] rule to add
-        #
-        #
-        def add_rule(rule)
-          # rubocop: disable Style/GlobalVars
-          $scriptExtension.get('automationManager').addRule(rule)
-          # rubocop: enable Style/GlobalVars
-        end
-      end
-    end
-  end
-end

data/lib/openhab/core/dsl/rule/rule_config.rb

@@ -1,153 +0,0 @@
-# frozen_string_literal: true
-
-require 'java'
-require 'pp'
-require 'core/dsl/property'
-require 'core/dsl/rule/triggers/cron'
-require 'core/dsl/rule/triggers/changed'
-require 'core/dsl/rule/triggers/channel'
-require 'core/dsl/rule/triggers/command'
-require 'core/dsl/rule/triggers/updated'
-require 'core/dsl/rule/guard'
-require 'core/dsl/entities'
-require 'core/dsl/time_of_day'
-require 'core/dsl'
-require 'core/dsl/timers'
-
-module OpenHAB
-  module Core
-    module DSL
-      #
-      # Creates and manages OpenHAB Rules
-      #
-      module Rule
-        #
-        # Rule configuration for OpenHAB Rules engine
-        #
-        class RuleConfig
-          include EntityLookup
-          include OpenHAB::Core::DSL::Rule::Triggers
-          include Guard
-          include DSLProperty
-          include Logging
-          extend OpenHAB::Core::DSL
-
-          java_import org.openhab.core.library.items.SwitchItem
-
-          # @return [Array] Of triggers
-          attr_reader :triggers
-
-          # @return [Array] Of trigger delays
-          attr_reader :trigger_delays
-
-          # @return [Array] Of trigger guards
-          attr_accessor :guard
-
-          #
-          # Struct holding a run block
-          #
-          Run = Struct.new(:block)
-
-          #
-          # Struct holding a Triggered block
-          #
-          Trigger = Struct.new(:block)
-
-          #
-          # Struct holding an otherwise block
-          #
-          Otherwise = Struct.new(:block)
-
-          #
-          # Struct holding rule delays
-          #
-          Delay = Struct.new(:duration)
-
-          prop_array :run, array_name: :run_queue, wrapper: Run
-          prop_array :triggered, array_name: :run_queue, wrapper: Trigger
-          prop_array :delay, array_name: :run_queue, wrapper: Delay
-          prop_array :otherwise, array_name: :run_queue, wrapper: Otherwise
-
-          prop :name
-          prop :description
-          prop :enabled
-          prop :between
-
-          #
-          # Create a new RuleConfig
-          #
-          # @param [Object] caller_binding The object initializing this configuration.
-          #   Used to execute within the object's context
-          #
-          def initialize(rule_name, caller_binding)
-            @triggers = []
-            @trigger_delays = {}
-            @caller = caller_binding.eval 'self'
-            enabled(true)
-            on_start(false)
-            name(rule_name)
-          end
-
-          #
-          # Start this rule on system startup
-          #
-          # @param [Boolean] run_on_start Run this rule on start, defaults to True
-          #
-          #
-          # rubocop: disable Style/OptionalBooleanParameter
-          # Disabled cop due to use in a DSL
-          def on_start(run_on_start = true)
-            @on_start = run_on_start
-          end
-          # rubocop: enable Style/OptionalBooleanParameter
-
-          #
-          # Checks if this rule should run on start
-          #
-          # @return [Boolean] True if rule should run on start, false otherwise.
-          #
-          def on_start?
-            @on_start
-          end
-
-          #
-          # Run the supplied block inside the object instance of the object that created the rule config
-          #
-          # @yield [] Block executed in context of the object creating the rule config
-          #
-          #
-          def my(&block)
-            @caller.instance_eval(&block)
-          end
-
-          #
-          # Create a logger where name includes rule name if name is set
-          #
-          # @return [Logging::Logger] Logger with name that appended with rule name if rule name is set
-          #
-          def logger
-            if name
-              Logging.logger(name.chomp.gsub(/\s+/, '_'))
-            else
-              super
-            end
-          end
-
-          #
-          # Inspect the config object
-          #
-          # @return [String] details of the config object
-          #
-          def inspect
-            "Name: (#{name}) " \
-            "Triggers: (#{triggers}) " \
-            "Run blocks: (#{run}) " \
-            "on_start: (#{on_start?}) " \
-            "Trigger Waits: #{trigger_delays} " \
-            "Trigger UIDs: #{triggers.map(&:id).join(', ')}"
-          end
-        end
-      end
-    end
-  end
-end

data/lib/openhab/core/dsl/rule/triggers/changed.rb

@@ -1,145 +0,0 @@
-# frozen_string_literal: true
-
-require 'core/log'
-
-module OpenHAB
-  module Core
-    module DSL
-      module Rule
-        #
-        # Module holds rule triggers
-        #
-        module Triggers
-          include Logging
-
-          #
-          # Struct capturing data necessary for a conditional trigger
-          #
-          TriggerDelay = Struct.new(:to, :from, :duration, :timer, :tracking_to, keyword_init: true) do
-            def timer_active?
-              timer&.is_active
-            end
-          end
-
-          #
-          # Creates a trigger item, group and thing changed
-          #
-          # @param [Object] items array of objects to create trigger for
-          # @param [to] to state for object to change for
-          # @param [from] from <description>
-          # @param [OpenHAB::Core::Duration] for Duration to delay trigger until to state is met
-          #
-          # @return [Trigger] OpenHAB trigger
-          #
-          def changed(*items, to: nil, from: nil, for: nil)
-            items.flatten.each 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
-              if (wait_duration = binding.local_variable_get(:for))
-                changed_wait(item, to: to, from: from, duration: wait_duration)
-              else
-                # Place in array and flatten to support multiple to elements or single or nil
-                [to].flatten.each do |to_state|
-                  create_changed_trigger(item, from, to_state)
-                end
-              end
-            end
-          end
-
-          private
-
-          #
-          # 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
-          #
-          # @return [Array] Array of current TriggerDelay objects
-          #
-          def changed_wait(item, duration:, to: nil, from: nil)
-            # If GroupItems specified, use the group state trigger instead
-            if item.is_a? GroupItems
-              config = { 'groupName' => item.group.name }
-              trigger = Trigger::GROUP_STATE_CHANGE
-            else
-              config = { 'itemName' => item.name }
-              trigger = Trigger::ITEM_STATE_CHANGE
-            end
-            logger.trace("Creating Changed Wait Change Trigger for #{config}")
-            trigger = append_trigger(trigger, config)
-            @trigger_delays[trigger.id] = TriggerDelay.new(to: to, from: from, duration: duration)
-          end
-
-          #
-          # Create a changed trigger
-          #
-          # @param [Object] item to create changed trigger on
-          # @param [String] from state to restrict trigger to
-          # @param [String] to state restrict trigger to
-          #
-          #
-          def create_changed_trigger(item, from, to)
-            trigger, config = case item
-                              when GroupItems then 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)
-          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 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 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]
-          end
-        end
-      end
-    end
-  end
-end