openhab-scripting 4.30.0 → 4.30.4

data/lib/openhab/dsl/types/quantity_type.rb

@@ -7,8 +7,8 @@ module OpenHAB
     module Types
       QuantityType = org.openhab.core.library.types.QuantityType
 
-      # global alias
-      ::QuantityType = QuantityType
+      # global alias - required for jrubyscripting addon <= OH3.2.0
+      ::QuantityType = QuantityType if ::QuantityType.is_a?(Java::JavaLang::Class)
 
       # @deprecated
       # Backwards-compatible alias
@@ -20,8 +20,8 @@ module OpenHAB
         include NumericType
 
         # private alias
-        ONE = org.openhab.core.library.unit.Units::ONE
-        private_constant :ONE
+        ONE_UNIT = org.openhab.core.library.unit.Units::ONE
+        private_constant :ONE_UNIT
 
         #
         # Convert this quantity into a another unit
@@ -46,8 +46,8 @@ module OpenHAB
         def <=>(other) # rubocop:disable Metrics
           logger.trace("(#{self.class}) #{self} <=> #{other} (#{other.class})")
           if other.is_a?(self.class)
-            return unitize(other.unit).compare_to(other) if unit == ONE
-            return compare_to(other.unitize(unit)) if other.unit == ONE
+            return unitize(other.unit).compare_to(other) if unit == ONE_UNIT
+            return compare_to(other.unitize(unit)) if other.unit == ONE_UNIT
 
             compare_to(other)
           elsif other.is_a?(Items::NumericItem) ||
@@ -88,7 +88,7 @@ module OpenHAB
           elsif other.is_a?(Type)
             [other, as(other.class)]
           elsif other.respond_to?(:to_d)
-            [QuantityType.new(other.to_d.to_java, ONE), self]
+            [QuantityType.new(other.to_d.to_java, ONE_UNIT), self]
           elsif other.is_a?(String)
             [QuantityType.new(other), self]
           end
@@ -215,7 +215,7 @@ module OpenHAB
           logger.trace("Converting #{self} to #{other_unit}")
 
           case unit
-          when ONE
+          when ONE_UNIT
             QuantityType.new(to_big_decimal, other_unit)
           when other_unit
             self
@@ -224,10 +224,10 @@ module OpenHAB
           end
         end
 
-        # if unit is +ONE+, return a plain Java BigDecimal
+        # if unit is +ONE_UNIT+, return a plain Java BigDecimal
         # @!visibility private
         def deunitize
-          return to_big_decimal if unit == ONE
+          return to_big_decimal if unit == ONE_UNIT
 
           self
         end

data/lib/openhab/log/logger.rb

@@ -61,6 +61,22 @@ module OpenHAB
         define_method("#{level}_enabled?") { @sl4fj_logger.send("is_#{level}_enabled") }
       end
 
+      #
+      # Logs a map of key(value) with an optional preamble at trace level
+      # @param [String] preamble to put at start of log message
+      # @param [Hash] key and values to log
+      def state(preamble = 'State:', **kwargs)
+        return unless trace_enabled?
+
+        states = kwargs.transform_keys(&:to_s)
+                       .transform_keys(&:capitalize)
+                       .transform_values { |v| v.nil? ? 'nil' : v }
+                       .map { |k, v| "#{k}(#{v})" }
+                       .join(' ')
+        trace "#{preamble} #{states}"
+      end
+      alias states state
+
       #
       # Cleans the backtrace of an error to remove internal calls. If logging is set
       # to debug or lower, the full backtrace is kept
@@ -245,9 +261,8 @@ module OpenHAB
       #
       def log_caller
         caller_locations.map(&:path)
-                        .grep_v(%r{openhab/core/})
                         .grep_v(/rubygems/)
-                        .grep_v(%r{lib/ruby})
+                        .grep_v(/openhab-scripting/)
                         .first
                         .then { |caller| File.basename(caller, '.*') if caller }
       end

data/lib/openhab/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: openhab-scripting
 version: !ruby/object:Gem::Version
-  version: 4.30.0
+  version: 4.30.4
 platform: ruby
 authors:
 - Brian O'Connell
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2022-01-18 00:00:00.000000000 Z
+date: 2022-01-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -102,17 +102,21 @@ files:
 - lib/openhab/dsl/rules/property.rb
 - lib/openhab/dsl/rules/rule.rb
 - lib/openhab/dsl/rules/rule_config.rb
+- lib/openhab/dsl/rules/rule_triggers.rb
 - lib/openhab/dsl/rules/terse.rb
 - 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/duration.rb
 - lib/openhab/dsl/rules/triggers/conditions/proc.rb
-- lib/openhab/dsl/rules/triggers/cron.rb
+- lib/openhab/dsl/rules/triggers/cron/cron.rb
+- lib/openhab/dsl/rules/triggers/cron/cron_handler.rb
 - lib/openhab/dsl/rules/triggers/generic.rb
 - lib/openhab/dsl/rules/triggers/trigger.rb
+- lib/openhab/dsl/rules/triggers/triggers.rb
 - lib/openhab/dsl/rules/triggers/updated.rb
-- lib/openhab/dsl/rules/triggers/watch.rb
+- lib/openhab/dsl/rules/triggers/watch/watch.rb
+- lib/openhab/dsl/rules/triggers/watch/watch_handler.rb
 - lib/openhab/dsl/states.rb
 - lib/openhab/dsl/things.rb
 - lib/openhab/dsl/time/month_day.rb

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

@@ -1,288 +0,0 @@
-# frozen_string_literal: true
-
-require 'java'
-
-module OpenHAB
-  module DSL
-    module Rules
-      #
-      # Cron type rules
-      #
-      module Triggers
-        #
-        # Returns a default map for cron expressions that fires every second
-        # This map is usually updated via merge by other methods to refine cron type triggers.
-        #
-        # @return [Hash] Map with symbols for :seconds, :minute, :hour, :dom, :month, :dow
-        #   configured to fire every second
-        #
-        def cron_expression_map
-          {
-            second: '*',
-            minute: '*',
-            hour: '*',
-            dom: '?',
-            month: '*',
-            dow: '?'
-          }
-        end
-
-        module_function :cron_expression_map
-
-        # @return [Hash] Map of days of the week from symbols to to OpenHAB cron strings
-        DAY_OF_WEEK_MAP = {
-          monday: 'MON',
-          tuesday: 'TUE',
-          wednesday: 'WED',
-          thursday: 'THU',
-          friday: 'FRI',
-          saturday: 'SAT',
-          sunday: 'SUN'
-        }.freeze
-
-        private_constant :DAY_OF_WEEK_MAP
-
-        # @return [Hash] Converts the DAY_OF_WEEK_MAP to map used by Cron Expression
-        DAY_OF_WEEK_EXPRESSION_MAP = DAY_OF_WEEK_MAP.transform_values { |v| cron_expression_map.merge(dow: v) }
-
-        private_constant :DAY_OF_WEEK_EXPRESSION_MAP
-
-        # @return [Hash] Create a set of cron expressions based on different time intervals
-        EXPRESSION_MAP = {
-          second: cron_expression_map,
-          minute: cron_expression_map.merge(second: '0'),
-          hour: cron_expression_map.merge(second: '0', minute: '0'),
-          day: cron_expression_map.merge(second: '0', minute: '0', hour: '0'),
-          week: cron_expression_map.merge(second: '0', minute: '0', hour: '0', dow: 'MON'),
-          month: cron_expression_map.merge(second: '0', minute: '0', hour: '0', dom: '1'),
-          year: cron_expression_map.merge(second: '0', minute: '0', hour: '0', dom: '1', month: '1')
-        }.merge(DAY_OF_WEEK_EXPRESSION_MAP)
-                         .freeze
-
-        private_constant :EXPRESSION_MAP
-
-        #
-        # Create a rule that executes at the specified interval
-        #
-        # @param [Object] value Symbol or Duration to execute this rule
-        # @param [Object] at TimeOfDay or String representing TimeOfDay in which to execute rule
-        #
-        #
-        def every(value, at: nil, attach: nil)
-          cron_expression = case value
-                            when Symbol then cron_from_symbol(value, at)
-                            when Java::JavaTime::Duration then cron_from_duration(value, at)
-                            else raise ArgumentExpression, 'Unknown interval'
-                            end
-          cron(cron_expression, attach: attach)
-        end
-
-        #
-        # Create a OpenHAB Cron trigger
-        #
-        # @param [String] expression OpenHAB style cron expression
-        #
-        def cron(expression, attach: nil)
-          append_trigger(Trigger::CRON, { 'cronExpression' => expression }, attach: attach)
-        end
-
-        private
-
-        #
-        # Create a cron map from a duration
-        #
-        # @param [java::time::Duration] duration
-        # @param [Object] at TimeOfDay or String representing time of day
-        #
-        # @return [Hash] map describing cron expression
-        #
-        def cron_from_duration(duration, at)
-          raise ArgumentError, '"at" cannot be used with duration' if at
-
-          map_to_cron(duration_to_map(duration))
-        end
-
-        #
-        # Create a cron map from a symbol
-        #
-        # @param [Symbol] symbol
-        # @param [Object] at TimeOfDay or String representing time of day
-        #
-        # @return [Hash] map describing cron expression created from symbol
-        #
-        def cron_from_symbol(symbol, at)
-          expression_map = EXPRESSION_MAP[symbol]
-          expression_map = at_condition(expression_map, at) if at
-          map_to_cron(expression_map)
-        end
-
-        #
-        # Map cron expression to to cron string
-        #
-        # @param [Map] map of cron expression
-        #
-        # @return [String] OpenHAB cron string
-        #
-        def map_to_cron(map)
-          %i[second minute hour dom month dow].map { |field| map.fetch(field) }.join(' ')
-        end
-
-        #
-        # Convert a Java Duration to a map for the map_to_cron method
-        #
-        # @param duration [Java::JavaTime::Duration] The duration object
-        #
-        # @return [Hash] a map suitable for map_to_cron
-        #
-        def duration_to_map(duration)
-          if duration.to_millis_part.zero? && duration.to_nanos_part.zero? && duration.to_days.zero?
-            %i[second minute hour].each do |unit|
-              to_unit_part = duration.public_send("to_#{unit}s_part")
-              next unless to_unit_part.positive?
-
-              to_unit = duration.public_send("to_#{unit}s")
-              break unless to_unit_part == to_unit
-
-              return EXPRESSION_MAP[unit].merge(unit => "*/#{to_unit}")
-            end
-          end
-          raise ArgumentError, "Cron Expression not supported for duration: #{duration}"
-        end
-
-        #
-        # If an at time is provided, parse that and merge the new fields into the expression.
-        #
-        # @param [<Type>] expression_map <description>
-        # @param [<Type>] at_time <description>
-        #
-        # @return [<Type>] <description>
-        #
-        def at_condition(expression_map, at_time)
-          if at_time
-            tod = at_time.is_a?(TimeOfDay::TimeOfDay) ? at_time : TimeOfDay::TimeOfDay.parse(at_time)
-            expression_map = expression_map.merge(hour: tod.hour, minute: tod.minute, second: tod.second)
-          end
-          expression_map
-        end
-
-        #
-        # Cron trigger that provides trigger ID
-        #
-        module Cron
-          include OpenHAB::Log
-
-          #
-          # Creates trigger types and trigger type factories for OpenHAB
-          #
-          def self.add_script_cron_handler
-            java_import org.openhab.core.automation.type.TriggerType
-            OpenHAB::Core.automation_manager.add_trigger_handler(
-              OpenHAB::DSL::Rules::Triggers::Cron::CRON_TRIGGER_MODULE_ID,
-              OpenHAB::DSL::Rules::Triggers::Cron::CronTriggerHandlerFactory.new
-            )
-
-            OpenHAB::Core.automation_manager.add_trigger_type(cron_trigger_type)
-            OpenHAB::Log.logger(self).trace('Added script cron trigger handler')
-          end
-
-          #
-          # Creates trigger types and trigger type factories for OpenHAB
-          #
-          private_class_method def self.cron_trigger_type
-            TriggerType.new(
-              OpenHAB::DSL::Rules::Triggers::Cron::CRON_TRIGGER_MODULE_ID,
-              nil,
-              'A specific instant occurs',
-              'Triggers when the specified instant occurs',
-              nil,
-              org.openhab.core.automation.Visibility::VISIBLE,
-              nil
-            )
-          end
-
-          # Trigger ID for Watch Triggers
-          CRON_TRIGGER_MODULE_ID = 'jsr223.jruby.CronTrigger'
-
-          # Cron Trigger Handler that provides trigger IDs
-          # Unfortunatly because the CronTriggerHandler in OpenHAB core is marked internal
-          # the entire thing must be recreated here
-          class CronTriggerHandler < org.openhab.core.automation.handler.BaseTriggerModuleHandler
-            include OpenHAB::Log
-            include org.openhab.core.scheduler.SchedulerRunnable
-            include org.openhab.core.automation.handler.TimeBasedTriggerHandler
-
-            # Provides access to protected fields
-            field_accessor :callback
-
-            # Creates a new CronTriggerHandler
-            # @param [Trigger] OpenHAB trigger associated with handler
-            #
-            def initialize(trigger)
-              @trigger = trigger
-              @scheduler = OpenHAB::Core::OSGI.service('org.openhab.core.scheduler.CronScheduler')
-              @expression = trigger.configuration.get('cronExpression')
-              super(trigger)
-            end
-
-            #
-            # Set the callback to execute when cron trigger fires
-            # @param [Object] callback to run
-            #
-            def setCallback(callback) # rubocop:disable Naming/MethodName
-              synchronized do
-                super(callback)
-                @scheduler.schedule(self, @expression)
-                logger.trace("Scheduled cron job '#{@expression}' for trigger '#{@trigger.id}'.")
-              end
-            end
-
-            #
-            # Get the temporal adjuster
-            # @return [CronAdjuster]
-            #
-            def getTemporalAdjuster # rubocop:disable Naming/MethodName
-              org.openhab.core.scheduler.CronAdjuster.new(expression)
-            end
-
-            #
-            # Execute the callback
-            #
-            def run
-              callback&.triggered(@trigger, { 'module' => @trigger.id })
-            end
-
-            #
-            # Displose of the handler
-            # cancel the cron scheduled task
-            #
-            def dispose
-              synchronized do
-                super
-                return unless @schedule
-
-                @schedule&.cancel(true)
-              end
-              logger.trace("cancelled job for trigger '#{@trigger.id}'.")
-            end
-          end
-
-          # Implements the ScriptedTriggerHandlerFactory interface to create a new Cron Trigger Handler
-          class CronTriggerHandlerFactory
-            include org.openhab.core.automation.module.script.rulesupport.shared.factories.ScriptedTriggerHandlerFactory
-
-            # Invoked by the OpenHAB core to get a trigger handler for the supllied trigger
-            # @param [Trigger] OpenHAB trigger
-            #
-            # @return [WatchTriggerHandler] trigger handler for supplied trigger
-            def get(trigger)
-              CronTriggerHandler.new(trigger)
-            end
-          end
-        end
-      end
-    end
-  end
-end
-
-# Add the cron handler to OpenHAB
-OpenHAB::DSL::Rules::Triggers::Cron.add_script_cron_handler