openhab-scripting 4.46.2 → 5.0.0

data/lib/openhab/dsl/time/time_of_day.rb

@@ -1,235 +0,0 @@
-# frozen_string_literal: true
-
-require 'openhab/log/logger'
-require 'openhab/dsl/types/date_time_type'
-require 'openhab/dsl/items/items'
-require 'time'
-
-module OpenHAB
-  module DSL
-    # Times without specific dates e.g. 6:00:00
-    # @author Brian O'Connell
-    # @since 0.0.1
-    module Between
-      java_import java.time.LocalTime
-      java_import java.time.format.DateTimeFormatterBuilder
-      java_import java.util.Locale
-
-      # Class that encapsulates a Time of Day, often viewed as hour-minute-second
-      # @author Brian O'Connell
-      # @since 0.0.1
-      class TimeOfDay
-        include Comparable
-        include OpenHAB::Log
-
-        # Immutable Java object containing Time Of Day
-        # @return [Java.Time.LocalTime] reprsenting the Time Of Day
-        attr_reader :local_time
-
-        # Constructs a TimeOfDay representing the time when called
-        # @since 0.0.1
-        # @return [TimeOfDay] representing time when method was invoked
-        def self.now
-          now = LocalTime.now()
-          TimeOfDay.new(h: now.hour, m: now.minute, s: now.second)
-        end
-
-        # Constructs a TimeOfDay representing midnight
-        # @since 0.0.1
-        # @return [TimeOfDay] representing midnight
-        def self.midnight
-          TimeOfDay.new(h: 0, m: 0, s: 0)
-        end
-
-        # Constructs a TimeOfDay representing noon
-        # @since 0.0.1
-        # @return [TimeOfDay] representing noon
-        def self.noon
-          TimeOfDay.new(h: 12, m: 0, s: 0)
-        end
-
-        # Constructs a TimeOfDay representing the time when called
-        # @since 0.0.1
-        # @param [String] string representation of TimeOfDay. Valid formats include "HH:MM:SS", "HH:MM",
-        #   "H:MM", "HH", "H", "H:MM am"
-        # @return [TimeOfDay] object created by parsing supplied string
-        def self.parse(string)
-          format = /(am|pm)$/i.match?(string) ? 'h[:mm[:ss]][ ]a' : 'H[:mm[:ss]]'
-          local_time = LocalTime.parse(string, DateTimeFormatterBuilder.new
-            .parseCaseInsensitive.appendPattern(format).toFormatter(Locale::ENGLISH))
-          TimeOfDay.new(h: local_time.hour, m: local_time.minute, s: local_time.second)
-        rescue java.time.format.DateTimeParseException => e
-          raise ArgumentError, e.message
-        end
-
-        # Constructs a TimeOfDay representing the time when called
-        # @since 0.0.1
-        # @option opts [Number] :h Hour of the day, defaults to 0
-        # @option opts [Number] :m Minute of the day, defaults to 0
-        # @option opts [Number] :s Second of the day, defaults to 0
-        # @return [TimeOfDay] representing time when method was invoked
-        # rubocop: disable Naming/MethodParameterName
-        # This method has a better feel with short parameter names
-        def initialize(h: 0, m: 0, s: 0)
-          @local_time = LocalTime.of(h, m, s)
-          freeze
-        end
-        # rubocop: enable Naming/MethodParameterName
-
-        # Returns true if the time falls within a range
-        def between?(range)
-          between(range).cover? self
-        end
-
-        # Returns the hour of the TimeOfDay
-        # @since 0.0.1
-        # @return [Number] Hour of the day, from 0 to 23
-        def hour
-          @local_time.hour
-        end
-
-        # Returns the minute of the TimeOfDay
-        # @since 0.0.1
-        # @return [Number] minute of the day, from 0 to 59
-        def minute
-          @local_time.minute
-        end
-
-        # Returns the second of the TimeOfDay
-        # @since 0.0.1
-        # @return [Number] second of the day, from 0 to 59
-        def second
-          @local_time.second
-        end
-
-        # Returns the string representation of the TimeOfDay
-        # @since 0.0.1
-        # @return [String] in any of the following formats depending on time representation HH:mm, HH:mm:ss,
-        #   HH:mm:ss.SSS, HH:mm:ss.SSSSSS, HH:mm:ss.SSSSSSSSS
-        def to_s
-          @local_time.to_s
-        end
-
-        # Compares one TimeOfDay to another
-        # @since 0.0.1
-        # @return [Number, nil] -1,0,1 if other TimeOfDay is less than, equal to, or greater than this TimeOfDay
-        #   or nil if an object other than TimeOfDay is provided
-        def <=>(other)
-          logger.trace("(#{self.class}) #{self} <=> #{other} (#{other.class})")
-          case other
-          when TimeOfDay then @local_time.compare_to(other.local_time)
-          when String then @local_time.compare_to(TimeOfDay.parse(other).local_time)
-          when LocalTime then @local_time.compare_to(other)
-          else
-            -(other <=> self)
-          end
-        end
-
-        # Creates a range that can be compared against time of day objects or strings
-        # to see if they are within the range
-        # @since 2.4.0
-        # @return Range object representing a TimeOfDay Range
-        def self.between(range)
-          raise ArgumentError, 'Supplied object must be a range' unless range.is_a? Range
-
-          start = to_time_of_day(range.begin)
-          ending = to_time_of_day(range.end)
-
-          start_sod = start.local_time.to_second_of_day
-          ending_sod = ending.local_time.to_second_of_day
-          ending_sod += TimeOfDayRangeElement::NUM_SECONDS_IN_DAY if ending_sod < start_sod
-
-          start_range = TimeOfDayRangeElement.new(sod: start_sod, range_begin: start_sod)
-          ending_range = TimeOfDayRangeElement.new(sod: ending_sod, range_begin: start_sod)
-          range.exclude_end? ? (start_range...ending_range) : (start_range..ending_range)
-        end
-
-        #
-        # Convert object to TimeOfDay object
-        #
-        # @param [Object] object TimeOfDay, String, or LocalTime to be converted
-        #
-        # @return [TimeOfDay] TimeOfDay created from supplied object
-        #
-        def self.to_time_of_day(object)
-          case object
-          when String then TimeOfDay.parse(object)
-          when Time, OpenHAB::DSL::Types::DateTimeType, OpenHAB::DSL::Items::DateTimeItem
-            TimeOfDay.new(h: object.hour, m: object.min, s: object.sec)
-          when LocalTime
-            TimeOfDay.new(h: object.hour, m: object.minute, s: object.second)
-          else object
-          end
-        end
-      end
-
-      # Modules that refines the Ruby Range object cover? and include? methods to support TimeOfDay ranges
-      class TimeOfDayRangeElement < Numeric
-        include Comparable
-        include OpenHAB::Log
-
-        NUM_SECONDS_IN_DAY = (60 * 60 * 24)
-
-        attr_reader :sod
-
-        def initialize(sod:, range_begin:)
-          @sod = sod
-          @range_begin = range_begin
-          super()
-        end
-
-        # Returns the current second of day advanced by 1 second
-        def succ
-          TimeOfDayRangeElement.new(sod: @sod + 1, range_begin: @range_begin)
-        end
-
-        # Compares one TimeOfDayRangeElement to another
-        # @since 2.4.0
-        # @return [Number, nil] -1,0,1 if other is less than, equal to, or greater than this TimeOfDay
-        def <=>(other)
-          other_second_of_day = to_second_of_day(other)
-          logger.trace do
-            "SOD(#{sod}) " \
-              "other SOD(#{other_second_of_day}) " \
-              "Other Class (#{other.class}) " \
-              "Result (#{sod <=> other_second_of_day})"
-          end
-          sod <=> other_second_of_day
-        end
-
-        private
-
-        #
-        # Convert object to the seconds of a day they reprsent
-        #
-        # @param [Object] object TimeofDay,String,Time, or TimeOfDayRangeElement to convert
-        #
-        # @return [Integer] seconds of day represented by supplied object
-        #
-        # rubocop:disable Metrics/AbcSize
-        # case statement needs to compare against multiple types
-        def to_second_of_day(object)
-          case object
-          when TimeOfDay then adjust_second_of_day(object.local_time.to_second_of_day)
-          when String then adjust_second_of_day(TimeOfDay.parse(object).local_time.to_second_of_day)
-          when ::Time, OpenHAB::DSL::Types::DateTimeType, OpenHAB::DSL::Items::DateTimeItem
-            adjust_second_of_day(TimeOfDay.new(h: object.hour, m: object.min, s: object.sec)
-            .local_time.to_second_of_day)
-          when TimeOfDayRangeElement then object.sod
-          else raise ArgumentError, "Supplied argument #{object.class} cannot be converted into Time Of Day Object"
-          end
-        end
-        # rubocop:enable Metrics/AbcSize
-
-        def adjust_second_of_day(second_of_day)
-          second_of_day += NUM_SECONDS_IN_DAY if second_of_day < @range_begin
-          second_of_day
-        end
-      end
-
-      MIDNIGHT = TimeOfDay.midnight
-      NOON = TimeOfDay.noon
-      ALL_DAY = TimeOfDay.between(TimeOfDay.new(h: 0, m: 0, s: 0)..TimeOfDay.new(h: 23, m: 59, s: 59))
-    end
-  end
-end

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

@@ -1,119 +0,0 @@
-# frozen_string_literal: true
-
-require 'set'
-require 'openhab/log/logger'
-require_relative 'reentrant_timer'
-
-module OpenHAB
-  module DSL
-    #
-    # Provides supporting classes for Timers module
-    #
-    module Support
-      #
-      # Manages data structures that track timers
-      #
-      class TimerManager
-        include OpenHAB::Log
-
-        attr_reader :timer_ids
-
-        def initialize
-          # Track timer IDs
-          @timer_ids = {}
-
-          # Reentrant timer lookups
-          @reentrant_timers = {}
-
-          # Tracks active timers
-          @timers = Set.new
-        end
-
-        #
-        # Adds the current timer to the set of rule timers if being tracked
-        #
-        # rubocop: disable Metrics/AbcSize
-        # It does not make sense to break this up into seperate components
-        def add(timer)
-          logger.trace("Adding #{timer} to timers")
-          @timers << timer
-
-          if timer.respond_to? :id
-            logger.trace("Adding #{timer} with id #{timer.id.inspect} timer ids")
-            @timer_ids[timer.id] = TimerSet.new unless @timer_ids[timer.id]
-            @timer_ids[timer.id] << timer
-          end
-
-          return unless timer.respond_to? :reentrant_id
-
-          logger.trace("Adding reeentrant #{timer} with reentrant id #{timer.reentrant_id} timer ids")
-          @reentrant_timers[timer.reentrant_id] = timer
-        end
-        # rubocop: enable Metrics/AbcSize
-
-        # Fetches the reentrant timer that matches the supplied id and block if it exists
-        #
-        # @param [Object] id Object to associate with timer
-        # @param [Block] block to execute, block is passed a Timer object
-        #
-        # @return [RentrantTimer] Timer object if it exists, nil otherwise
-        #
-        def reentrant_timer(id:, &block)
-          reentrant_key = ReentrantTimer.reentrant_id(id: id, &block)
-          logger.trace("Checking for existing reentrant timer for #{reentrant_key}")
-          @reentrant_timers[reentrant_key]
-        end
-
-        #
-        # Delete the current timer to the set of rule timers if being tracked
-        #
-        def delete(timer)
-          logger.trace("Removing #{timer} from timers")
-          @timers.delete(timer)
-          if timer.respond_to?(:id) && (timers = @timer_ids[timer.id])
-            timers.delete(timer)
-            @timer_ids.delete(timer.id) if timers.empty?
-          end
-          @reentrant_timers.delete(timer.reentrant_id) if timer.respond_to? :reentrant_id
-        end
-
-        #
-        # Cancels all active timers
-        #
-        def cancel_all
-          logger.trace("Canceling #{@timers.length} timers")
-          @timers.each(&:cancel)
-          @timer_ids.clear
-          @reentrant_timers.clear
-          @timers.clear
-        end
-      end
-
-      #
-      # Provide additional methods for the timers set
-      #
-      class TimerSet < Set
-        #
-        # A shorthand to cancel all the timer objects held within the set
-        # so that timers[timer_id].cancel is equivalent to timers[timer_id].each(&:cancel)
-        #
-        def cancel
-          each(&:cancel)
-        end
-        # @deprecated Please use {cancel} instead
-        alias cancel_all cancel
-
-        #
-        # A shorthand to reschedule all the timer objects held within the set
-        #
-        # @param [Duration] duration An optional duration to reschedule
-        #
-        # @return [TimerSet] Set of timers
-        #
-        def reschedule(duration = nil)
-          each { |timer| timer.reschedule duration }
-        end
-      end
-    end
-  end
-end

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

@@ -1,38 +0,0 @@
-# frozen_string_literal: true
-
-require 'openhab/log/logger'
-require_relative 'timer'
-
-module OpenHAB
-  module DSL
-    # A reentrant timer is a timer that is automatically rescheduled
-    # when the block it refers to is encountered again
-    #
-    # @author Brian O'Connell
-    # @since 2.0.0
-    class ReentrantTimer < Timer
-      include OpenHAB::Log
-
-      attr_reader :id, :reentrant_id
-
-      #
-      # Create a new Timer Object
-      #
-      # @param [Duration] duration Duration until timer should fire
-      # @param [Block] block Block to execute when timer fires
-      #
-      def initialize(duration:, id:, thread_locals: {}, &block)
-        raise 'Reentrant timers do not work in dynamically generated code' unless block.source_location
-
-        @id = id
-        @reentrant_id = self.class.reentrant_id(id: id, &block)
-        super(duration: duration, thread_locals: thread_locals, &block)
-        logger.trace("Created Reentrant Timer #{self} with reentrant Key #{@reentrant_id}")
-      end
-
-      def self.reentrant_id(id:, &block)
-        [id, block.source_location].flatten
-      end
-    end
-  end
-end

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

@@ -1,132 +0,0 @@
-# frozen_string_literal: true
-
-require 'java'
-require 'delegate'
-require 'forwardable'
-require 'openhab/log/logger'
-require 'openhab/core/thread_local'
-
-module OpenHAB
-  module DSL
-    java_import org.openhab.core.model.script.actions.ScriptExecution
-
-    # 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?
-
-      #
-      # Create a new Timer Object
-      #
-      # @param [Duration] duration Duration until timer should fire
-      # @param [Block] block Block to execute when timer fires
-      #
-      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
-
-        semaphore.synchronize do
-          @timer = ScriptExecution.createTimer(OpenHAB::DSL.to_zdt(@duration), timer_block(semaphore, &block))
-          @rule_timers = Thread.current[:rule_timers]
-          super(@timer)
-          Timers.timer_manager.add(self)
-        end
-      end
-
-      #
-      # Reschedule timer
-      #
-      # @param [Duration] duration
-      #
-      # @return [Timer] Rescheduled timer instances
-      #
-      def reschedule(duration = nil)
-        duration ||= @duration
-
-        Timers.timer_manager.add(self)
-        @timer.reschedule(OpenHAB::DSL.to_zdt(duration))
-      end
-
-      #
-      # Cancel timer
-      #
-      # @return [Boolean] True if cancel was successful, false otherwise
-      #
-      def cancel
-        Timers.timer_manager.delete(self)
-        @timer.cancel
-      end
-
-      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 {
-          OpenHAB::DSL.import_presets
-          semaphore.synchronize do
-            Timers.timer_manager.delete(self)
-            thread_local(**@thread_locals) do
-              yield(self)
-            end
-          end
-        }
-      end
-    end
-
-    #
-    # Convert TemporalAmount (Duration), seconds (float, integer), and Ruby Time to ZonedDateTime
-    # Note: TemporalAmount is added to now
-    #
-    # @param [Object] timestamp to convert
-    #
-    # @return [ZonedDateTime]
-    #
-    def self.to_zdt(timestamp)
-      logger.trace("Converting #{timestamp} (#{timestamp.class}) to ZonedDateTime")
-      return unless timestamp
-
-      case timestamp
-      when java.time.temporal.TemporalAmount then ZonedDateTime.now.plus(timestamp)
-      when ZonedDateTime then timestamp
-      when Time then timestamp.to_java(ZonedDateTime)
-      else
-        to_zdt(seconds_to_duration(timestamp)) ||
-          raise(ArgumentError, 'Timestamp must be a ZonedDateTime, a Duration, a Numeric, or a Time object')
-      end
-    end
-
-    #
-    # Convert numeric seconds to a Duration object
-    #
-    # @param [Float, Integer] secs The number of seconds in integer or float
-    #
-    # @return [Duration]
-    #
-    def self.seconds_to_duration(secs)
-      return unless secs
-
-      if secs.respond_to?(:to_f)
-        secs.to_f.seconds
-      elsif secs.respond_to?(:to_i)
-        secs.to_i.seconds
-      end
-    end
-  end
-end

data/lib/openhab/dsl/timers.rb

@@ -1,77 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'timers/timer'
-require_relative 'timers/manager'
-require_relative 'timers/reentrant_timer'
-
-module OpenHAB
-  module DSL
-    #
-    # Provides access to and ruby wrappers around OpenHAB timers
-    #
-    module Timers
-      include OpenHAB::Log
-
-      # Manages timers
-      @timer_manager = OpenHAB::DSL::Support::TimerManager.new
-
-      class << self
-        attr_reader :timer_manager
-      end
-
-      module_function
-
-      #
-      # Execute the supplied block after the specified duration
-      #
-      # @param [Duration] duration after which to execute the block
-      # @param [Object] id to associate with timer
-      # @param [Block] block to execute, block is passed a Timer object
-      #
-      # @return [Timer] Timer object
-      #
-      def after(duration, id: nil, &block)
-        # Carry rule name to timer thread
-        thread_locals = { RULE_NAME: Thread.current[:RULE_NAME] } if Thread.current[:RULE_NAME]
-        thread_locals ||= {}
-        return Timers.reentrant_timer(duration: duration, thread_locals: thread_locals, id: id, &block) if id
-
-        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
-      # @return [Hash] hash of user specified ids to sets of times
-      def timers
-        Timers.timer_manager.timer_ids
-      end
-
-      #
-      # Cancels all active timers
-      #
-      def self.cancel_all
-        @timer_manager.cancel_all
-      end
-      Core::ScriptHandling.script_unloaded { cancel_all }
-
-      # Create or reschedule a reentrant time
-      #
-      # @param [Duration] duration after which to execute the block
-      # @param [Object] id to associate with timer
-      # @param [Block] block to execute, block is passed a Timer object
-      # @return [ReentrantTimer] Timer object
-      def self.reentrant_timer(duration:, id:, thread_locals: nil, &block)
-        timer = @timer_manager.reentrant_timer(id: id, &block)
-        if timer
-          logger.trace("Reentrant timer found - #{timer}")
-          timer.cancel
-        else
-          logger.trace('No reentrant timer found, creating new timer')
-        end
-        OpenHAB::DSL::ReentrantTimer.new(duration: duration, id: id, thread_locals: thread_locals, &block)
-      end
-    end
-  end
-end

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

@@ -1,23 +0,0 @@
-# frozen_string_literal: true
-
-module OpenHAB
-  module DSL
-    module Types
-      IncreaseDecreaseType = org.openhab.core.library.types.IncreaseDecreaseType
-
-      # Adds methods to core OpenHAB IncreaseDecreaseType to make it more
-      # natural in Ruby
-      class IncreaseDecreaseType # rubocop:disable Lint/EmptyClass
-        # @!parse include Type
-
-        # @!method increase?
-        #   Check if == +INCREASE+
-        #   @return [Boolean]
-
-        # @!method decrease?
-        #   Check if == +DECREASE+
-        #   @return [Boolean]
-      end
-    end
-  end
-end

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

@@ -1,23 +0,0 @@
-# frozen_string_literal: true
-
-module OpenHAB
-  module DSL
-    module Types
-      NextPreviousType = org.openhab.core.library.types.NextPreviousType
-
-      # Adds methods to core OpenHAB NextPreviousType to make it more
-      # natural in Ruby
-      class NextPreviousType # rubocop:disable Lint/EmptyClass
-        # @!parse include Type
-
-        # @!method next?
-        #   Check if == +NEXT+
-        #   @return [Boolean]
-
-        # @!method previous?
-        #   Check if == +PREVIOUS+
-        #   @return [Boolean]
-      end
-    end
-  end
-end

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

@@ -1,28 +0,0 @@
-# frozen_string_literal: true
-
-module OpenHAB
-  module DSL
-    module Types
-      OnOffType = org.openhab.core.library.types.OnOffType
-
-      # Adds methods to core OpenHAB OnOffType to make it more natural in Ruby
-      class OnOffType
-        # @!parse include Type
-
-        # @!method on?
-        #   Check if == +ON+
-        #   @return [Boolean]
-
-        # @!method off?
-        #   Check if == +OFF+
-        #   @return [Boolean]
-
-        # Invert the type
-        # @return [OnOffType] +OFF+ if +ON+, +ON+ if +OFF+
-        def !
-          on? ? OFF : ON
-        end
-      end
-    end
-  end
-end