openhab-scripting 2.16.2 → 2.19.0

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

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

@@ -1,55 +0,0 @@
-# frozen_string_literal: true
-
-require 'core/log'
-require 'openhab/core/dsl/rule/triggers/trigger'
-
-module OpenHAB
-  module Core
-    module DSL
-      module Rule
-        #
-        # Channel triggers
-        #
-        module Triggers
-          include Logging
-
-          #
-          # Creates a channel trigger
-          #
-          # @param [Array] channels array to create triggers for on form of 'binding_id:type_id:thing_id#channel_id'
-          #   or 'channel_id' if thing is provided
-          # @param [thing] thing to create trigger for if not specified with the channel
-          # @param [String] triggered specific triggering condition to match for trigger
-          #
-          #
-          def channel(*channels, thing: nil, triggered: nil)
-            channels.flatten.each do |channel|
-              channel = [thing, channel].join(':') if thing
-              logger.trace("Creating channel trigger for channel(#{channel}), thing(#{thing}), trigger(#{triggered})")
-              [triggered].flatten.each do |trigger|
-                create_channel_trigger(channel, trigger)
-              end
-            end
-          end
-
-          private
-
-          #
-          # Create a trigger for a channel
-          #
-          # @param [Channel] channel to look for triggers
-          # @param [Trigger] trigger specific channel trigger to match
-          #
-          #
-          def create_channel_trigger(channel, trigger)
-            config = { 'channelUID' => channel }
-            config['event'] = trigger.to_s unless trigger.nil?
-            config['channelUID'] = channel
-            logger.trace("Creating Change Trigger for #{config}")
-            @triggers << Trigger.trigger(type: Trigger::CHANNEL_EVENT, config: config)
-          end
-        end
-      end
-    end
-  end
-end