openhab-scripting 2.16.4 → 2.19.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1cf495280ef0c286169b0d453f3b03688563ab017b0fc5707d0243bfd24d43b1
-  data.tar.gz: 7e1e590a1c0f25598d0e95841068faca6e9c98261764c0a53dd74b3ac36b82d6
+  metadata.gz: 74777515cf7cb008bb80d87ad05a1af9dcd8a260ebeb458b7d9ee24c4aa63453
+  data.tar.gz: 28bd0a8950695ac78e91177fe3884e86f278efdba8d695e1cf7f4637a36571a0
 SHA512:
-  metadata.gz: 27acec53581abe0cc1df086e92b14591840c437e5cdb189fec7d69f8f72e62c442d10d6781d03c8a5b91e40fbb8d39ac7986d3a82f5c77bb3e84501dc3c314fe
-  data.tar.gz: 58e558b957c89ea67bf405cb8530e0436d532179b07b9e34b1e79087a639796f4aac25c4a18eebe076ae869116f93fd679a51eb576ca29006a7c54222ef271ad
+  metadata.gz: 87f8af88c6f73b7498c054253544a4ac71940f634f1fa45a80c7bc1518c6c9906d3e099a5f0013afa0b4f454f3c06239479507c81afe000ed07e1f5bd052b75f
+  data.tar.gz: 5b2b7560d230a1d04725a5635f923b919439bc2156be7fc10474c2f9396c87823939f0cb590db8feb978577c6880e059ed2eb0cf83edd64c04ae915693ccb532

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

@@ -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/dsl/units.rb

@@ -3,7 +3,7 @@
 require 'java'
 
 # Import Imperial and SI Units overriding provided values
-%i[ImperialUnits SIUnits].each do |type|
+%i[Units ImperialUnits SIUnits].each do |type|
   Object.send(:remove_const, type)
   java_import "org.openhab.core.library.unit.#{type}"
 end

data/lib/openhab/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: openhab-scripting
 version: !ruby/object:Gem::Version
-  version: 2.16.4
+  version: 2.19.2
 platform: ruby
 authors:
 - Brian O'Connell
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2021-02-12 00:00:00.000000000 Z
+date: 2021-02-16 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