openhab-scripting 2.17.0 → 2.19.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e194635ad3998d2bfb2cb5326522012655b2197a4083ee3def1e5ec572af1bc4
-  data.tar.gz: b8b1d13fab2d7bcbfcf8599e22bf7c51d88e27434d385dc6db22cf5127476569
+  metadata.gz: 92d53929fa49d74df4409422669c809e146723ef88862019ee77dbf8f671b2e0
+  data.tar.gz: 3d421f3dd17058b3319bf1973da3c39f4dcc74b1a04ac365b1361be0afb59ab8
 SHA512:
-  metadata.gz: 2c924211ea0801f90fcd0b1829f932b5c4a4c7629f00a82212c2188351e6848d9deb94a6d0c20edf4202fdb77a661c64a9ad69cf779ae06e4deffc95aa6c7cca
-  data.tar.gz: 175c047b5703f52f2e8edbcd7b8df127f19561e35cbe61a31afba9c48199606cf3fdd4b4372f292eb8dc34c4bf700c6171851fc20e976d3d2eb9cc7df693f2fe
+  metadata.gz: ef748b3b0b3f7e4e85a7b2523df44101ceb64c9170358e5521fb2601880aefd5fd789c71d88c2115b339323081013e53032daf7e1b7e25ffda9010493da9cbec
+  data.tar.gz: 7468514e99d37e180e694b07ef751c5f9badf56dbc94f43e9ed982c9a7799760c37940dfaaa5c0adaecbfb3d82505a184401bad565ab88c56c0401207c3f2176

data/lib/openhab/core/entity_lookup.rb

@@ -7,6 +7,8 @@ require 'openhab/dsl/group'
 require 'openhab/log/logger'
 require 'openhab/dsl/items/number_item'
 require 'openhab/dsl/items/string_item'
+require 'openhab/dsl/items/datetime_item'
+require 'openhab/dsl/items/rollershutter_item'
 
 # Automation lookup and injection of OpenHab entities
 java_import org.openhab.core.items.GroupItem
@@ -84,6 +86,9 @@ module OpenHAB
       #
       # @return [Object] the ruby wrapper for the item
       #
+      # rubocop: disable Metrics/MethodLength
+      # rubocop: disable Metrics/AbcSize
+      # Disabled line length and branch size - case dispatch pattern
       private_class_method def self.decorate_item(item)
         case item
         when GroupItem
@@ -92,10 +97,16 @@ module OpenHAB
           OpenHAB::DSL::Items::NumberItem.new(item)
         when Java::Org.openhab.core.library.items::StringItem
           OpenHAB::DSL::Items::StringItem.new(item)
+        when Java::Org.openhab.core.library.items::DateTimeItem
+          OpenHAB::DSL::Items::DateTimeItem.new(item)
+        when Java::Org.openhab.core.library.items::RollershutterItem
+          OpenHAB::DSL::Items::RollershutterItem.new(item)
         else
           item
         end
       end
+      # rubocop: enable Metrics/AbcSize
+      # rubocop: enable Metrics/MethodLength
 
       #
       # Looks up a Thing in the OpenHAB registry replacing '_' with ':'

data/lib/openhab/dsl/dsl.rb

@@ -13,11 +13,13 @@ require 'openhab/dsl/timers'
 require 'openhab/dsl/group'
 require 'openhab/dsl/things'
 require 'openhab/dsl/items/items'
+require 'openhab/dsl/items/datetime_item'
 require 'openhab/dsl/items/number_item'
 require 'openhab/dsl/time_of_day'
 require 'openhab/dsl/gems'
 require 'openhab/dsl/persistence'
 require 'openhab/dsl/units'
+require 'openhab/dsl/types/datetime'
 require 'openhab/dsl/types/quantity'
 require 'openhab/dsl/states'
 

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

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+require 'forwardable'
+require 'java'
+require 'time'
+require 'openhab/dsl/types/datetime'
+
+module OpenHAB
+  module DSL
+    module Items
+      #
+      # Delegation to OpenHAB DateTime Item
+      #
+      # @author Anders Alfredsson
+      #
+      class DateTimeItem
+        extend Forwardable
+        include Comparable
+
+        def_delegator :@datetime_item, :to_s
+
+        #
+        # Create a new DateTimeItem
+        #
+        # @param [Java::org::openhab::core::libarary::items::DateTimeItem] datetime_item Openhab DateTimeItem to
+        # delegate to
+        #
+        def initialize(datetime_item)
+          @datetime_item = datetime_item
+        end
+
+        #
+        # Return an instance of DateTime that wraps the DateTimeItem's state
+        #
+        # @return [OpenHAB::DSL::Types::DateTime] Wrapper for the Item's state, or nil if it has no state
+        #
+        def to_dt
+          OpenHAB::DSL::Types::DateTime.new(@datetime_item.state) if state?
+        end
+
+        #
+        # Compare the Item's state to another Item or object that can be compared
+        #
+        # @param [Object] other Other objet to compare against
+        #
+        # @return [Integer] -1, 0 or 1 depending on the result of the comparison
+        #
+        def <=>(other)
+          return unless state?
+
+          logger.trace("Comparing self (#{self.class}) to #{other} (#{other.class})")
+          other = other.to_dt if other.is_a? DateTimeItem
+          to_dt <=> other
+        end
+
+        #
+        # Get the time zone of the Item
+        #
+        # @return [String] The timezone in `[+-]hh:mm(:ss)` format or nil if the Item has no state
+        #
+        def zone
+          to_dt.zone if state?
+        end
+
+        #
+        # Check if missing method can be delegated to other contained objects
+        #
+        # @param [String, Symbol] meth The method name to check for
+        #
+        # @return [Boolean] true if DateTimeItem or DateTime responds to the method, false otherwise
+        #
+        def respond_to_missing?(meth, *)
+          @datetime_item.respond_to?(meth) || to_dt.respond_to?(meth)
+        end
+
+        #
+        # Forward missing methods to the OpenHAB Item, or a DateTime object wrapping its state
+        #
+        # @param [String] meth method name
+        # @param [Array] args arguments for method
+        # @param [Proc] block <description>
+        #
+        # @return [Object] Value from delegated method in OpenHAB NumberItem
+        #
+        def method_missing(meth, *args, &block)
+          if @datetime_item.respond_to?(meth)
+            @datetime_item.__send__(meth, *args, &block)
+          elsif state?
+            to_dt.send(meth, *args, &block)
+          else
+            raise NoMethodError, "undefined method `#{meth}' for #{self.class}"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,179 @@
+# frozen_string_literal: true
+
+require 'forwardable'
+require 'java'
+
+module OpenHAB
+  module DSL
+    module Items
+      #
+      # Delegator to OpenHAB Rollershutter Item
+      #
+      class RollershutterItem < Numeric
+        extend Forwardable
+        include Comparable
+
+        def_delegator :@rollershutter_item, :to_s
+
+        java_import Java::OrgOpenhabCoreLibraryTypes::PercentType
+        java_import Java::OrgOpenhabCoreLibraryTypes::UpDownType
+        java_import Java::OrgOpenhabCoreLibraryTypes::StopMoveType
+
+        #
+        # Creates a new RollershutterItem
+        #
+        # @param [Java::OrgOpenhabCoreLibraryItems::RollershutterItem] rollershutter_item
+        #   The OpenHAB RollershutterItem to delegate to
+        #
+        def initialize(rollershutter_item)
+          logger.trace("Wrapping #{rollershutter_item}")
+          @rollershutter_item = rollershutter_item
+
+          super()
+        end
+
+        #
+        # Check if the rollershutter is up
+        #
+        # @return [Boolean] true if the rollershutter is up, false otherwise
+        #
+        def up?
+          state.as(UpDownType) == UpDownType::UP
+        end
+
+        #
+        # Check if the rollershutter is down
+        #
+        # @return [Boolean] true if the rollershutter is down, false otherwise
+        #
+        def down?
+          state.as(UpDownType) == UpDownType::DOWN
+        end
+
+        #
+        # Returns the rollershutter's position
+        #
+        # @return [Java::OrgOpenhabCoreLibraryTypes::PercentType] the position of the rollershutter
+        #
+        def position
+          state.as(PercentType)
+        end
+
+        #
+        # Compare the rollershutter's position against another object
+        #
+        # @param [Object] other object to compare against
+        #
+        # @return [Integer] -1, 0 or 1 depending on the result of the comparison
+        #
+        def <=>(other)
+          case other
+          when PercentType, Java::OrgOpenhabCoreLibraryTypes::DecimalType then position.compare_to(other)
+          when Numeric then position.int_value <=> other
+          when RollershutterItem then position.compare_to(other.position)
+          when UpDownType then state.as(UpDownType) == other
+          end
+        end
+
+        #
+        # Coerce self into other to enable calculations
+        #
+        # @param [Numeric] other Other numeric to coerce into
+        #
+        # @return [Array<Numeric>] an array of other and self coerced into other's type
+        #
+        def coerce(other)
+          raise ArgumentError, "Cannot coerce to #{other.class}" unless other.is_a? Numeric
+
+          case other
+          when Integer then [other, position.int_value]
+          when Float then [other, position.float_value]
+          end
+        end
+
+        #
+        # Case equality
+        #
+        # @param [Java::OrgOpenhabCoreLibraryTypes::UpDownType, Numeric] other Other object to compare against
+        #
+        # @return [Boolean] true if self can be defined as other, false otherwise
+        #
+        def ===(other)
+          super unless other.is_a? UpDownType
+
+          state.as(UpDownType).equals(other)
+        end
+
+        #
+        # Sends an UP command to the Item
+        #
+        def up
+          command UpDownType::UP
+        end
+
+        #
+        # Sends a DOWN command to the Item
+        #
+        def down
+          command UpDownType::DOWN
+        end
+
+        #
+        # Sends a STOP command to the Item
+        #
+        def stop
+          command StopMoveType::STOP
+        end
+
+        #
+        # Sends a MOVE command to the Item
+        #
+        def move
+          command StopMoveType::MOVE
+        end
+
+        #
+        # Define math operations
+        #
+        %i[+ - * / %].each do |operator|
+          define_method(operator) do |other|
+            right, left = coerce(other)
+            left.send(operator, right)
+          end
+        end
+
+        #
+        # Checks if this method responds to the missing method
+        #
+        # @param [String] meth Name of the method to check
+        # @param [Boolean] _include_private boolean if private methods should be checked
+        #
+        # @return [Boolean] true if this object will respond to the supplied method, false otherwise
+        #
+        def respond_to_missing?(meth, _include_private = false)
+          @rollershutter_item.respond_to?(meth) || position.respond_to?(meth)
+        end
+
+        #
+        # Forward missing methods to Openhab RollershutterItem or the PercentType representing it's state
+        #   if they are defined
+        #
+        # @param [String] meth method name
+        # @param [Array] args arguments for method
+        # @param [Proc] block <description>
+        #
+        # @return [Object] Value from delegated method in OpenHAB NumberItem
+        #
+        def method_missing(meth, *args, &block)
+          if @rollershutter_item.respond_to?(meth)
+            @rollershutter_item.__send__(meth, *args, &block)
+          elsif position.respond_to?(meth)
+            position.__send__(meth, *args, &block)
+          else
+            raise NoMethodError, "No method `#{meth}' defined for #{self.class}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/openhab/dsl/monkey_patch/ruby/ruby.rb

@@ -4,4 +4,5 @@
 require 'openhab/dsl/monkey_patch/ruby/range'
 require 'openhab/dsl/monkey_patch/ruby/number'
 require 'openhab/dsl/monkey_patch/ruby/string'
+require 'openhab/dsl/monkey_patch/ruby/time'
 require 'bigdecimal/util'

data/lib/openhab/dsl/monkey_patch/ruby/time.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module OpenHAB
+  module DSL
+    module MonkeyPatch
+      module Ruby
+        #
+        # Extend Time to make to_s return string parseable by OpenHAB
+        #
+        module TimeExtensions
+          include OpenHAB::Core
+
+          #
+          # Convert to ISO 8601 format
+          #
+          # @return [Java::JavaTime::Duration] Duration with number of units from self
+          #
+          def to_s
+            strftime '%FT%T.%N%:z'
+          end
+        end
+      end
+    end
+  end
+end
+
+#
+# Extend Time class with to_s method
+#
+class Time
+  prepend OpenHAB::DSL::MonkeyPatch::Ruby::TimeExtensions
+end

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

@@ -6,3 +6,4 @@ require 'openhab/dsl/monkey_patch/types/on_off_type'
 require 'openhab/dsl/monkey_patch/types/decimal_type'
 require 'openhab/dsl/monkey_patch/types/percent_type'
 require 'openhab/dsl/monkey_patch/types/quantity_type'
+require 'openhab/dsl/monkey_patch/types/up_down_type'

data/lib/openhab/dsl/monkey_patch/types/up_down_type.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require 'java'
+module OpenHAB
+  module DSL
+    module MonkeyPatch
+      #
+      # Patches OpenHAB types
+      #
+      module Types
+        java_import Java::OrgOpenhabCoreLibraryTypes::UpDownType
+
+        #
+        # MonkeyPatching UpDownType
+        #
+        class UpDownType
+          #
+          # Check if the supplied object is case equals to self
+          #
+          # @param [Object] other object to compare
+          #
+          # @return [Boolean] True if the other object is a RollershutterItem and has the same state
+          #
+          def ===(other)
+            super unless other.is_a? OpenHAB::DSL::Items::RollershutterItem
+
+            equals(other.state.as(UpDownType))
+          end
+        end
+      end
+    end
+  end
+end

data/lib/openhab/dsl/rules/automation_rule.rb

@@ -70,7 +70,7 @@ module OpenHAB
         def create_queue(inputs)
           case check_guards(event: inputs&.dig('event'))
           when true
-            @run_queue.dup
+            @run_queue.dup.grep_v(RuleConfig::Otherwise)
           when false
             @run_queue.dup.grep(RuleConfig::Otherwise)
           end
@@ -145,16 +145,14 @@ module OpenHAB
         #
         #
         def process_trigger_delay(trigger_delay, mod, inputs)
-          if check_trigger_guards(trigger_delay, inputs)
+          if trigger_delay.timer_active?
+            process_active_timer(inputs, mod, trigger_delay)
+          elsif check_trigger_guards(trigger_delay, inputs)
             logger.trace("Trigger Guards Matched for #{trigger_delay}, delaying rule execution")
             # Add timer and attach timer to delay object, and also state being tracked to so timer can be cancelled if
             #   state changes
             # Also another timer should not be created if changed to same value again but instead rescheduled
-            if trigger_delay.timer_active?
-              process_active_timer(inputs, mod, trigger_delay)
-            else
-              create_trigger_delay_timer(inputs, mod, trigger_delay)
-            end
+            create_trigger_delay_timer(inputs, mod, trigger_delay)
           else
             logger.trace("Trigger Guards did not match for #{trigger_delay}, ignoring trigger.")
           end
@@ -173,7 +171,8 @@ module OpenHAB
           trigger_delay.timer = after(trigger_delay.duration) do
             logger.trace("Delay Complete for #{trigger_delay}, executing rule")
             trigger_delay.timer = nil
-            process_queue(@run_queue.dup, mod, inputs)
+            queue = create_queue(inputs)
+            process_queue(queue, mod, inputs)
           end
           trigger_delay.tracking_to = inputs['newState']
         end

data/lib/openhab/dsl/time_of_day.rb

@@ -2,8 +2,9 @@
 
 require 'java'
 require 'openhab/log/logger'
+require 'openhab/dsl/items/datetime_item'
+require 'openhab/dsl/types/datetime'
 require 'time'
-require 'date'
 
 module OpenHAB
   module DSL
@@ -172,8 +173,9 @@ module OpenHAB
           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 then adjust_second_of_day(TimeOfDay.new(h: object.hour, m: object.min,
-                                                            s: object.sec).local_time.to_second_of_day)
+          when Time, OpenHAB::DSL::Types::DateTime, 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 cannot be converted into Time Of Day Object'
           end
@@ -216,6 +218,8 @@ module OpenHAB
       private_class_method def to_time_of_day(object)
         case object
         when String then TimeOfDay.parse(object)
+        when Time, OpenHAB::DSL::Types::DateTime, OpenHAB::DSL::Items::DateTimeItem
+          TimeOfDay.new(h: object.hour, m: object.min, s: object.sec)
         else object
         end
       end

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

@@ -0,0 +1,326 @@
+# frozen_string_literal: true
+
+require 'java'
+require 'forwardable'
+require 'time'
+
+module OpenHAB
+  module DSL
+    module Types
+      #
+      # Ruby implementation for OpenHAB DateTimeType
+      #
+      # @author Anders Alfredsson
+      #
+      # rubocop: disable Metrics/ClassLength
+      # Disabled because this class has a single responsibility, there does not appear a logical
+      # way of breaking it up into multiple classes
+      class DateTime
+        extend Forwardable
+        include Comparable
+        include OpenHAB::Log
+
+        def_delegator :datetime, :to_s
+        def_delegator :zoned_date_time, :month_value, :month
+        def_delegator :zoned_date_time, :minute, :min
+        def_delegator :zoned_date_time, :second, :sec
+        def_delegator :zoned_date_time, :nano, :nsec
+        def_delegator :zoned_date_time, :to_epoch_second, :to_i
+        alias inspect to_s
+
+        java_import Java::OrgOpenhabCoreLibraryTypes::DateTimeType
+        java_import java.time.ZonedDateTime
+        java_import java.time.Instant
+        java_import java.time.ZoneId
+        java_import java.time.ZoneOffset
+        java_import java.time.Duration
+
+        #
+        # Regex expression to identify strings defining a time in hours, minutes and optionally seconds
+        #
+        TIME_ONLY_REGEX = /\A\d\d:\d\d(:\d\d)?\Z/.freeze
+
+        #
+        # Regex expression to identify strings defining a time in hours, minutes and optionally seconds
+        #
+        DATE_ONLY_REGEX = /\A\d{4}-\d\d-\d\d\Z/.freeze
+
+        attr_reader :datetime
+
+        #
+        # Create a new DateTime instance wrapping an OpenHAB DateTimeType
+        #
+        # @param [Java::org::openhab::core::library::types::DateTimeType] datetime The DateTimeType instance to
+        #   delegate to, or an object that can be converted to a DateTimeType
+        #
+        def initialize(datetime)
+          @datetime = case datetime
+                      when DateTimeType
+                        datetime
+                      when ZonedDateTime
+                        DateTimeType.new(datetime)
+                      else
+                        raise "Unexpected type #{datetime.class} provided to DateTime initializer"
+                      end
+        end
+
+        #
+        # Compare thes DateTime object to another
+        #
+        # @param [Object] other Other object to compare against
+        #
+        # @return [Integer] -1, 0 or 1 depending on the outcome
+        #
+        def <=>(other)
+          case other
+          when DateTime, DateTimeType, DateTimeItem
+            zoned_date_time.to_instant.compare_to(other.zoned_date_time.to_instant)
+          when TimeOfDay::TimeOfDay, TimeOfDay::TimeOfDayRangeElement
+            to_tod <=> other
+          when String
+            self <=> DateTime.parse(DATE_ONLY_REGEX =~ other ? "#{other}'T'00:00:00#{zone}" : other)
+          else
+            self <=> DateTime.from(other)
+          end
+        end
+
+        #
+        # Adds another object to this DateTime
+        #
+        # @param [Object] other Object to add to this. Can be a Numeric, another DateTime/Time/DateTimeType, a
+        #   Duration or a String that can be parsed into a DateTimeType or Time object
+        #
+        # @return [DateTime] A new DateTime object representing the result of the calculation
+        #
+        def +(other)
+          logger.trace("Adding #{other} (#{other.class}) to #{self}")
+          case other
+          when Numeric then DateTime.from(to_time + other)
+          when DateTime, Time then self + other.to_f
+          when DateTimeType, String then self + DateTime.from(other).to_f
+          when Duration then DateTime.new(zoned_date_time.plus(other))
+          end
+        end
+
+        #
+        # Subtracts another object from this DateTime
+        #
+        # @param [Object] other Object to subtract fom this. Can be a Numeric, another DateTime/Time/DateTimeType, a
+        #   Duration or a String that can be parsed into a DateTimeType or Time object
+        #
+        # @return [DateTime, Float] A new DateTime object representing the result of the calculation, or a Float
+        #   representing the time difference in seconds if the subtraction is between two time objects
+        #
+        def -(other)
+          logger.trace("Subtracting #{other} (#{other.class}) from self")
+          case other
+          when Numeric then DateTime.from(to_time - other)
+          when String
+            dt = DateTime.parse(other)
+            TIME_ONLY_REGEX =~ other ? self - dt.to_f : time_diff(dt)
+          when Duration then DateTime.new(zoned_date_time.minus(other))
+          when Time, DateTime, DateTimeType, DateTimeItem then time_diff(other)
+          end
+        end
+
+        #
+        # Convert this DateTime to a ruby Time object
+        #
+        # @return [Time] A Time object representing the same instant and timezone
+        #
+        def to_time
+          Time.at(to_i, nsec, :nsec).localtime(utc_offset)
+        end
+
+        #
+        # Convert the time part of this DateTime to a TimeOfDay object
+        #
+        # @return [TimeOfDay] A TimeOfDay object representing the time
+        #
+        def to_time_of_day
+          TimeOfDay::TimeOfDay.new(h: hour, m: minute, s: second)
+        end
+
+        alias to_tod to_time_of_day
+
+        #
+        # Returns the value of time as a floating point number of seconds since the Epoch
+        #
+        # @return [Float] Number of seconds since the Epoch, with nanosecond presicion
+        #
+        def to_f
+          zoned_date_time.to_epoch_second + zoned_date_time.nano / 1_000_000_000
+        end
+
+        #
+        # The ZonedDateTime representing the state
+        #
+        # @return [Java::java::time::ZonedDateTime] ZonedDateTime representing the state
+        #
+        def zoned_date_time
+          @datetime.zonedDateTime
+        end
+
+        alias to_zdt zoned_date_time
+
+        #
+        # The offset in seconds from UTC
+        #
+        # @return [Integer] The offset from UTC, in seconds
+        #
+        def utc_offset
+          zoned_date_time.offset.total_seconds
+        end
+
+        #
+        # Returns true if time represents a time in UTC (GMT)
+        #
+        # @return [Boolean] true if utc_offset == 0, false otherwise
+        #
+        def utc?
+          utc_offset.zero?
+        end
+
+        #
+        # The timezone
+        #
+        # @return [String] The timezone in `[+-]hh:mm(:ss)` format ('Z' for UTC) or nil if the Item has no state
+        #
+        def zone
+          zoned_date_time.zone.id
+        end
+
+        #
+        # Check if missing method can be delegated to other contained objects
+        #
+        # @param [String, Symbol] meth the method name to check for
+        #
+        # @return [Boolean] true if DateTimeType, ZonedDateTime or Time responds to the method, false otherwise
+        #
+        def respond_to_missing?(meth, *)
+          @datetime.respond_to?(meth) ||
+            zoned_date_time.respond_to?(meth) ||
+            Time.instance_methods.include?(meth.to_sym)
+        end
+
+        #
+        # Forward missing methods to the OpenHAB DateTimeType, its ZonedDateTime object or a ruby Time
+        # object representing the same instant
+        #
+        # @param [String] meth method name
+        # @param [Array] args arguments for method
+        # @param [Proc] block <description>
+        #
+        # @return [Object] Value from delegated method in OpenHAB NumberItem
+        #
+        def method_missing(meth, *args, &block)
+          if @datetime.respond_to?(meth)
+            @datetime.__send__(meth, *args, &block)
+          elsif zoned_date_time.respond_to?(meth)
+            zoned_date_time.__send__(meth, *args, &block)
+          elsif Time.instance_methods.include?(meth.to_sym)
+            to_time.send(meth, *args, &block)
+          else
+            raise NoMethodError, "undefined method `#{meth}' for #{self.class}"
+          end
+        end
+
+        #
+        # Converts other objects to a DateTimeType
+        #
+        # @param [String, Numeric, Time] datetime an object that can be parsed or converted into
+        #   a DateTimeType
+        #
+        # @return [Java::org::openhab::core::library::types::DateTimeType] Object representing the same time
+        #
+        def self.from(datetime)
+          case datetime
+          when String
+            parse(datetime)
+          when Numeric
+            from_numeric(datetime)
+          when Time
+            from_time(datetime)
+          else
+            raise "Cannot convert #{datetime.class} to DateTime"
+          end
+        end
+
+        #
+        # Converts a Numeric into a DateTimeType
+        #
+        # @param [Numeric] numeric A Integer or Float representing the number of seconds since the epoch
+        #
+        # @return [Java::org::openhab::core::library::types::DateTimeType] Object representing the same time
+        #
+        def self.from_numeric(numeric)
+          case numeric
+          when Integer
+            DateTime.new(ZonedDateTime.ofInstant(Instant.ofEpochSecond(datetime), ZoneId.systemDefault))
+          else
+            DateTime.new(ZonedDateTime.ofInstant(Instant.ofEpochSecond(datetime.to_i,
+                                                                       ((datetime % 1) * 1_000_000_000).to_i),
+                                                 ZoneId.systemDefault))
+          end
+        end
+
+        #
+        # Converts a ruby Time object to an OpenHAB DateTimeType
+        #
+        # @param [Time] time The Time object to be converted
+        #
+        # @return [Java::org::openhab::core::library::types::DateTimeType] Object representing the same time
+        #
+        def self.from_time(time)
+          instant = Instant.ofEpochSecond(time.to_i, time.nsec)
+          zone_id = ZoneId.of_offset('UTC', ZoneOffset.of_total_seconds(time.utc_offset))
+          DateTime.new(ZonedDateTime.ofInstant(instant, zone_id))
+        end
+
+        #
+        # Parses a string representing a time into an OpenHAB DateTimeType. First tries to parse it
+        #   using the DateTimeType's parser, then falls back to the ruby Time.parse
+        #
+        # @param [String] time_string The string to be parsed
+        #
+        # @return [Java::org::openhab::core::library::types::DateTimeType] Object representing the same time
+        #
+        def self.parse(time_string)
+          time_string += 'Z' if TIME_ONLY_REGEX =~ time_string
+          DateTime.new(DateTimeType.new(time_string))
+        rescue Java::JavaLang::StringIndexOutOfBoundsException, Java::JavaLang::IllegalArgumentException
+          # Try ruby's Time.parse if OpenHAB's DateTimeType parser fails
+          begin
+            time = Time.parse(time_string)
+            DateTime.from(time)
+          rescue ArgumentError
+            raise "Unable to parse #{time_string} into a DateTime"
+          end
+        end
+
+        private
+
+        #
+        # Calculates the difference in time between this instance and another time object
+        #
+        # @param [Time, DateTime, DateTimeItem, Java::org::openhab::core::library::types::DateTimeType] time_obj
+        #   The other time object to subtract from self
+        #
+        # @return [Float] The time difference between the two objects, in seconds
+        #
+        def time_diff(time_obj)
+          logger.trace("Calculate time difference between #{self} and #{time_obj}")
+          case time_obj
+          when Time
+            to_time - time_obj
+          when DateTime, DateTimeItem
+            self - time_obj.to_time
+          when DateTimeType
+            self - DateTime.new(time_obj).to_time
+          end
+        end
+      end
+    end
+  end
+end
+# rubocop: enable Metrics/ClassLength

data/lib/openhab/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: openhab-scripting
 version: !ruby/object:Gem::Version
-  version: 2.17.0
+  version: 2.19.3
 platform: ruby
 authors:
 - Brian O'Connell
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2021-02-12 00:00:00.000000000 Z
+date: 2021-02-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -39,8 +39,10 @@ files:
 - lib/openhab/dsl/dsl.rb
 - lib/openhab/dsl/gems.rb
 - lib/openhab/dsl/group.rb
+- lib/openhab/dsl/items/datetime_item.rb
 - lib/openhab/dsl/items/items.rb
 - lib/openhab/dsl/items/number_item.rb
+- lib/openhab/dsl/items/rollershutter_item.rb
 - lib/openhab/dsl/items/string_item.rb
 - lib/openhab/dsl/monkey_patch/actions/actions.rb
 - lib/openhab/dsl/monkey_patch/actions/script_thing_actions.rb
@@ -59,12 +61,14 @@ files:
 - lib/openhab/dsl/monkey_patch/ruby/range.rb
 - lib/openhab/dsl/monkey_patch/ruby/ruby.rb
 - lib/openhab/dsl/monkey_patch/ruby/string.rb
+- lib/openhab/dsl/monkey_patch/ruby/time.rb
 - lib/openhab/dsl/monkey_patch/types/decimal_type.rb
 - lib/openhab/dsl/monkey_patch/types/on_off_type.rb
 - lib/openhab/dsl/monkey_patch/types/open_closed_type.rb
 - lib/openhab/dsl/monkey_patch/types/percent_type.rb
 - lib/openhab/dsl/monkey_patch/types/quantity_type.rb
 - lib/openhab/dsl/monkey_patch/types/types.rb
+- lib/openhab/dsl/monkey_patch/types/up_down_type.rb
 - lib/openhab/dsl/persistence.rb
 - lib/openhab/dsl/rules/automation_rule.rb
 - lib/openhab/dsl/rules/guard.rb
@@ -81,6 +85,7 @@ files:
 - lib/openhab/dsl/things.rb
 - lib/openhab/dsl/time_of_day.rb
 - lib/openhab/dsl/timers.rb
+- lib/openhab/dsl/types/datetime.rb
 - lib/openhab/dsl/types/quantity.rb
 - lib/openhab/dsl/units.rb
 - lib/openhab/log/configuration.rb