openhab-scripting 4.32.7 → 4.34.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1741788eaf0826f7b5e2c69935c96b21399771b3332a89debc77992c4ef687d0
-  data.tar.gz: b1200a71458efe21d389631bc29d2ef7d073ae5128706009a12b9a35af559bd3
+  metadata.gz: 4f374040f733839953804416c74c3690e1c9643143c1af746218528d7e1da50f
+  data.tar.gz: 5db466d2078bd40e3c47dd699296e9da8270a8c292d1ada94f67c3ff7dd8762f
 SHA512:
-  metadata.gz: 9317316f15b212005f6f9cb4013c6fb80739b8c427a8685b0610d5c6127a1ed676584f62258efe38a757966f4c9e51f61064a70a486ec2bd4d0e98c52dbe9255
-  data.tar.gz: d28a7872616e92eefa43e198f8211ee6ccb4408f418bb942ea82b6a8c9af572f9d6adc2e8fe929d8a2ba5bff19138f238be0e7951f75bf9567800e5681c68381
+  metadata.gz: 0200afe739c2e8a3f4dccc02dd138b3946b610276186baeb1ae729633e5be359e466b0046e3c2c8151124968d94d918e7fbde72e22f3994996832d379f30a817
+  data.tar.gz: b9f109a2ee3665319110ee3354bba1efa9d5cbebe31634ca0b78e84aaea39ad3a07dc96ac5a744b52eda4dc19cd8c890abd6a53c2d5181eaa13f14f9afd9760a

data/lib/openhab/core/thread_local.rb

@@ -18,7 +18,7 @@ module OpenHAB
       # @param [Hash] values Keys and values to set for running thread, if hash is nil no values are set
       #
       def self.thread_local(**values)
-        old_values = values.map { |key, _value| [key, Thread.current[key]] }.to_h
+        old_values = values.to_h { |key, _value| [key, Thread.current[key]] }
         values.each { |key, value| Thread.current[key] = value }
         logger.trace "Executing block with thread local context: #{values} - old context: #{old_values}"
         yield

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

@@ -50,15 +50,17 @@ module OpenHAB
         # If +ensure_states+ is active (by block or chained method), then
         # check if this item is in the command's state before actually
         # sending the command
-        def command(command)
-          return super unless Thread.current[:ensure_states]
+        %i[command update].each do |ensured_method|
+          define_method(ensured_method) do |command|
+            return super(command) unless Thread.current[:ensure_states]
 
-          logger.trace do
-            "#{name} ensure #{command}, format_type_pre: #{format_type_pre(command)}, current state: #{state}"
-          end
-          return if state == format_type_pre(command)
+            logger.trace do
+              "#{name} ensure #{command}, format_type_pre: #{format_type_pre(command)}, current state: #{state}"
+            end
+            return if state == format_type_pre(command)
 
-          super
+            super(command)
+          end
         end
         alias << command
       end

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

@@ -145,7 +145,7 @@ module OpenHAB
             include OpenHAB::Log
             include OpenHAB::Core::ThreadLocal
 
-            def initialize(timed_command_details, semaphore, &block) # rubocop:disable Metric/MethodLength
+            def initialize(timed_command_details, semaphore, &block) # rubocop:disable Metrics/MethodLength
               super()
               @semaphore = semaphore
               @timed_command_details = timed_command_details

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

@@ -13,16 +13,19 @@ module OpenHAB
         #
         # Create a rule that executes at the specified interval
         #
-        # @param [Object] value Symbol or Duration to execute this rule
+        # @param [Object] value String, Symbol, Duration, or MonthDay to execute this rule
         # @param [Object] at TimeOfDay or String representing TimeOfDay in which to execute rule
         # @param [Object] attach object to be attached to the trigger
         #
         #
         def every(value, at: nil, attach: nil)
+          return every(MonthDay.parse(value), at: at, attach: attach) if value.is_a? String
+
           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'
+                            when Java::JavaTime::MonthDay then Cron.from_monthday(value, at)
+                            else raise ArgumentError, 'Unknown interval'
                             end
           cron(cron_expression, attach: attach)
         end
@@ -32,8 +35,18 @@ module OpenHAB
         #
         # @param [String] expression OpenHAB style cron expression
         # @param [Object] attach object to be attached to the trigger
+        # @param [Hash] elements cron expression elements (second, minute, hour, dom, month, dow, year)
         #
-        def cron(expression, attach: nil)
+        def cron(expression = nil, attach: nil, **fields)
+          if fields.any?
+            raise ArgumentError, 'Cron elements cannot be used with a cron expression' if expression
+
+            cron_expression = Cron.from_fields(fields)
+            return cron(cron_expression, attach: attach)
+          end
+
+          raise ArgumentError, 'Missing cron expression or elements' unless expression
+
           cron = Cron.new(rule_triggers: @rule_triggers)
           cron.trigger(config: { 'cronExpression' => expression }, attach: attach)
         end
@@ -59,7 +72,8 @@ module OpenHAB
               hour: '*',
               dom: '?',
               month: '*',
-              dow: '?'
+              dow: '?',
+              year: '*'
             }.freeze
           private_constant :CRON_EXPRESSION_MAP
 
@@ -96,7 +110,7 @@ module OpenHAB
           #
           # Create a cron map from a duration
           #
-          # @param [java::time::Duration] duration
+          # @param [Java::JavaTime::Duration] duration
           # @param [Object] at TimeOfDay or String representing time of day
           #
           # @return [Hash] map describing cron expression
@@ -107,6 +121,20 @@ module OpenHAB
             map_to_cron(duration_to_map(duration))
           end
 
+          #
+          # Create a cron map from a MonthDay
+          #
+          # @param [Java::JavaTime::MonthDay] month_day
+          # @param [Object] at TimeOfDay or String representing time of day
+          #
+          # @return [Hash] map describing cron expression
+          #
+          def self.from_monthday(monthday, at)
+            expression_map = EXPRESSION_MAP[:day].merge(month: monthday.month_value, dom: monthday.day_of_month)
+            expression_map = at_condition(expression_map, at) if at
+            map_to_cron(expression_map)
+          end
+
           #
           # Create a cron map from a symbol
           #
@@ -121,6 +149,19 @@ module OpenHAB
             map_to_cron(expression_map)
           end
 
+          #
+          # Create a cron map from cron elements
+          #
+          # @param [Hash] elements Cron fields (second, minute, hour, dom, month, dow, year)
+          #
+          # @return [Hash] map describing cron expression
+          #
+          def self.from_fields(fields)
+            fields = fields.transform_values { |value| value.to_s.gsub(/\s+/, '') }
+            expression_map = CRON_EXPRESSION_MAP.merge(fields)
+            map_to_cron(expression_map)
+          end
+
           #
           # Map cron expression to to cron string
           #
@@ -129,7 +170,7 @@ module OpenHAB
           # @return [String] OpenHAB cron string
           #
           def self.map_to_cron(map)
-            %i[second minute hour dom month dow].map { |field| map.fetch(field) }.join(' ')
+            %i[second minute hour dom month dow year].map { |field| map.fetch(field) }.join(' ')
           end
 
           #

data/lib/openhab/dsl/timers/reentrant_timer.rb

@@ -10,7 +10,7 @@ module OpenHAB
     #
     # @author Brian O'Connell
     # @since 2.0.0
-    class ReentrantTimer < Timers::Timer
+    class ReentrantTimer < Timer
       include OpenHAB::Log
 
       attr_reader :id, :reentrant_id

data/lib/openhab/dsl/timers/timer.rb

@@ -8,114 +8,109 @@ require 'openhab/core/thread_local'
 
 module OpenHAB
   module DSL
-    #
-    # Provides access to and ruby wrappers around OpenHAB timers
-    #
-    module Timers
-      java_import org.openhab.core.model.script.actions.ScriptExecution
-      java_import java.time.ZonedDateTime
+    java_import org.openhab.core.model.script.actions.ScriptExecution
+    java_import java.time.ZonedDateTime
 
-      # Ruby wrapper for OpenHAB Timer
-      # This class implements delegator to delegate methods to the OpenHAB timer
-      #
-      # @author Brian O'Connell
-      # @since 2.0.0
-      class Timer < SimpleDelegator
-        include OpenHAB::Log
-        include OpenHAB::Core::ThreadLocal
-        extend Forwardable
+    # Ruby wrapper for OpenHAB Timer
+    # This class implements delegator to delegate methods to the OpenHAB timer
+    #
+    # @author Brian O'Connell
+    # @since 2.0.0
+    class Timer < SimpleDelegator
+      include OpenHAB::Log
+      include OpenHAB::Core::ThreadLocal
+      extend Forwardable
 
-        def_delegator :@timer, :has_terminated, :terminated?
+      def_delegator :@timer, :has_terminated, :terminated?
 
-        #
-        # Create a new Timer Object
-        #
-        # @param [Duration] duration Duration until timer should fire
-        # @param [Block] block Block to execute when timer fires
-        #
-        # rubocop: disable Metrics/MethodLength
-        def initialize(duration:, thread_locals: {}, &block)
-          @duration = duration
-          @thread_locals = thread_locals
+      #
+      # Create a new Timer Object
+      #
+      # @param [Duration] duration Duration until timer should fire
+      # @param [Block] block Block to execute when timer fires
+      #
+      # rubocop: disable Metrics/MethodLength
+      def initialize(duration:, thread_locals: {}, &block)
+        @duration = duration
+        @thread_locals = thread_locals
 
-          # A semaphore is used to prevent a race condition in which calling the block from the timer thread
-          # occurs before the @timer variable can be set resulting in @timer being nil
-          semaphore = Mutex.new
+        # A semaphore is used to prevent a race condition in which calling the block from the timer thread
+        # occurs before the @timer variable can be set resulting in @timer being nil
+        semaphore = Mutex.new
 
-          semaphore.synchronize do
-            @timer = ScriptExecution.createTimer(
-              ZonedDateTime.now.plus(to_duration(@duration)), timer_block(semaphore, &block)
-            )
-            @rule_timers = Thread.current[:rule_timers]
-            super(@timer)
-            Timers.timer_manager.add(self)
-          end
+        semaphore.synchronize do
+          @timer = ScriptExecution.createTimer(
+            ZonedDateTime.now.plus(to_duration(@duration)), timer_block(semaphore, &block)
+          )
+          @rule_timers = Thread.current[:rule_timers]
+          super(@timer)
+          Timers.timer_manager.add(self)
         end
-        # rubocop: enable Metrics/MethodLength
+      end
+      # rubocop: enable Metrics/MethodLength
 
-        #
-        # Reschedule timer
-        #
-        # @param [Duration] duration
-        #
-        # @return [Timer] Rescheduled timer instances
-        #
-        def reschedule(duration = nil)
-          duration ||= @duration
+      #
+      # Reschedule timer
+      #
+      # @param [Duration] duration
+      #
+      # @return [Timer] Rescheduled timer instances
+      #
+      def reschedule(duration = nil)
+        duration ||= @duration
 
-          Timers.timer_manager.add(self)
-          @timer.reschedule(ZonedDateTime.now.plus(to_duration(duration)))
-        end
+        Timers.timer_manager.add(self)
+        @timer.reschedule(ZonedDateTime.now.plus(to_duration(duration)))
+      end
 
-        #
-        # Cancel timer
-        #
-        # @return [Boolean] True if cancel was successful, false otherwise
-        #
-        def cancel
-          Timers.timer_manager.delete(self)
-          @timer.cancel
-        end
+      #
+      # Cancel timer
+      #
+      # @return [Boolean] True if cancel was successful, false otherwise
+      #
+      def cancel
+        Timers.timer_manager.delete(self)
+        @timer.cancel
+      end
 
-        private
+      private
 
-        #
-        # Constructs a block to execute timer within
-        #
-        # @param [Semaphore] semaphore to obtain before executing
-        #
-        # @return [Proc] Block for timer to execute
-        #
-        def timer_block(semaphore)
-          proc {
-            semaphore.synchronize do
-              Timers.timer_manager.delete(self)
-              thread_local(@thread_locals) do
-                yield(self)
-              end
+      #
+      # Constructs a block to execute timer within
+      #
+      # @param [Semaphore] semaphore to obtain before executing
+      #
+      # @return [Proc] Block for timer to execute
+      #
+      def timer_block(semaphore)
+        proc {
+          semaphore.synchronize do
+            Timers.timer_manager.delete(self)
+            thread_local(@thread_locals) do
+              yield(self)
             end
-          }
-        end
-
-        #
-        # Convert argument to a duration
-        #
-        # @param [Java::JavaTimeTemporal::TemporalAmount, #to_f, #to_i, nil] duration Duration
-        #
-        # @raise if duration cannot be used for a timer
-        #
-        # @return Argument converted to seconds if it responds to #to_f or #to_i, otherwise duration unchanged
-        #
-        def to_duration(duration)
-          if duration.nil? || duration.is_a?(Java::JavaTimeTemporal::TemporalAmount)
-            duration
-          elsif duration.respond_to?(:to_f)
-            duration.to_f.seconds
-          elsif duration.respond_to?(:to_i)
-            duration.to_i.seconds
-          else
-            raise ArgumentError, "Supplied argument '#{duration}' cannot be converted to a duration"
           end
+        }
+      end
+
+      #
+      # Convert argument to a duration
+      #
+      # @param [Java::JavaTimeTemporal::TemporalAmount, #to_f, #to_i, nil] duration Duration
+      #
+      # @raise if duration cannot be used for a timer
+      #
+      # @return Argument converted to seconds if it responds to #to_f or #to_i, otherwise duration unchanged
+      #
+      def to_duration(duration)
+        if duration.nil? || duration.is_a?(Java::JavaTimeTemporal::TemporalAmount)
+          duration
+        elsif duration.respond_to?(:to_f)
+          duration.to_f.seconds
+        elsif duration.respond_to?(:to_i)
+          duration.to_i.seconds
+        else
+          raise ArgumentError, "Supplied argument '#{duration}' cannot be converted to a duration"
         end
       end
     end

data/lib/openhab/dsl/timers.rb

@@ -36,8 +36,10 @@ module OpenHAB
         thread_locals ||= {}
         return Timers.reentrant_timer(duration: duration, thread_locals: thread_locals, id: id, &block) if id
 
-        Timer.new(duration: duration, thread_locals: thread_locals, &block)
+        OpenHAB::DSL::Timer.new(duration: duration, thread_locals: thread_locals, &block)
       end
+      # An alias for +after+
+      alias create_timer after
 
       #
       # Provdes access to the hash for mapping timer ids to the set of active timers associated with that id

data/lib/openhab/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: openhab-scripting
 version: !ruby/object:Gem::Version
-  version: 4.32.7
+  version: 4.34.0
 platform: ruby
 authors:
 - Brian O'Connell
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2022-03-07 00:00:00.000000000 Z
+date: 2022-03-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler