openhab-scripting 2.17.0 → 2.18.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e194635ad3998d2bfb2cb5326522012655b2197a4083ee3def1e5ec572af1bc4
-  data.tar.gz: b8b1d13fab2d7bcbfcf8599e22bf7c51d88e27434d385dc6db22cf5127476569
+  metadata.gz: 44145354fe523ea40a69c6cf2ba81f2684e9982580fe5bc3996f07ab56202e71
+  data.tar.gz: ac579ab41fe3f005d7e5a87df7d18c7f32efa9f49c40f251e07620f238b9e65f
 SHA512:
-  metadata.gz: 2c924211ea0801f90fcd0b1829f932b5c4a4c7629f00a82212c2188351e6848d9deb94a6d0c20edf4202fdb77a661c64a9ad69cf779ae06e4deffc95aa6c7cca
-  data.tar.gz: 175c047b5703f52f2e8edbcd7b8df127f19561e35cbe61a31afba9c48199606cf3fdd4b4372f292eb8dc34c4bf700c6171851fc20e976d3d2eb9cc7df693f2fe
+  metadata.gz: 00026266f68f7d1c9b1ba442ffe0933ac90b5dbe80b61aa2db25470bf3c166c3f5f73067fbba4c292ad31eaeb6913e56299fc9c3625b1e7ce3efc8aaeac69665
+  data.tar.gz: 497fee2e97d90f9e64bd2ba324b9612ed44becb0aec7eb51d4706f1414e3313afeeb3242b5ece884be2fb15525c190a753116548fc2a022c0d4159cff2a8f559

data/lib/openhab/core/entity_lookup.rb

@@ -7,6 +7,7 @@ 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'
 
 # Automation lookup and injection of OpenHab entities
 java_import org.openhab.core.items.GroupItem
@@ -84,6 +85,8 @@ module OpenHAB
       #
       # @return [Object] the ruby wrapper for the item
       #
+      # rubocop: disable Metrics/MethodLength
+      # Method length check disabled - case dispatch pattern
       private_class_method def self.decorate_item(item)
         case item
         when GroupItem
@@ -92,10 +95,13 @@ 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)
         else
           item
         end
       end
+      # 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/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/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.18.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: openhab-scripting
 version: !ruby/object:Gem::Version
-  version: 2.17.0
+  version: 2.18.0
 platform: ruby
 authors:
 - Brian O'Connell
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2021-02-12 00:00:00.000000000 Z
+date: 2021-02-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -39,6 +39,7 @@ 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/string_item.rb
@@ -59,6 +60,7 @@ 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
@@ -81,6 +83,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