openhab-scripting 4.47.0 → 5.0.0

data/lib/openhab/core_ext/java/local_time.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+require_relative "time"
+
+module OpenHAB
+  module CoreExt
+    module Java
+      java_import java.time.LocalTime
+
+      #
+      # Extensions to {java.time.LocalTime}
+      #
+      # @example
+      #   break_time = LocalTime::NOON
+      #
+      #   if LocalTime.now > LocalTime.of(17, 30) # comparing two LocalTime objects
+      #     # do something
+      #   elsif LocalTime.now < LocalTime.parse('8:30') # comparison against a string
+      #     # do something
+      #   end
+      #   four_pm = LocalTime.parse('16:00')
+      #
+      # @example
+      #   # Trigger security light between sunset and sunrise when motion is detected
+      #   rule 'Outside Light Motion' do
+      #     updated Motion_Sensor, to: OPEN
+      #     run do
+      #       astro = things['astro:sun:home']
+      #       sunrise = astro.get_event_time('SUN_RISE', nil, nil).to_local_time
+      #       sunset = astro.get_event_time('SUN_SET', nil, nil).to_local_time
+      #       next if (sunrise..sunset).cover?(Time.now)
+      #
+      #       Security_Light.on for: 10.minutes
+      #     end
+      #   end
+      #
+      class LocalTime
+        include Between
+        # @!parse include Time
+
+        class << self
+          # @!attribute [r] now
+          #   @return [LocalTime]
+
+          # @!visibility private
+          alias_method :raw_parse, :parse
+
+          #
+          # Parses strings in the form "h[:mm[:ss]] [am/pm]" when no formatter is given.
+          #
+          # @param [String] string
+          # @param [java.time.format.DateTimeFormatter] formatter The formatter to use
+          # @return [LocalTime]
+          #
+          def parse(string, formatter = nil)
+            return raw_parse(string, formatter) if formatter
+
+            format = /(am|pm)$/i.match?(string) ? "h[:mm[:ss][.S]][ ]a" : "H[:mm[:ss][.S]]"
+            java_send(:parse, [java.lang.CharSequence, java.time.format.DateTimeFormatter],
+                      string, java.time.format.DateTimeFormatterBuilder.new
+                              .parse_case_insensitive
+                              .parse_lenient
+                              .append_pattern(format)
+                              .to_formatter(java.util.Locale::ENGLISH))
+          end
+        end
+
+        # @param [TemporalAmount, Numeric] other
+        #   If other is a Numeric, it's interpreted as seconds.
+        # @return [LocalTime]
+        def -(other)
+          return minus(other.seconds) if other.is_a?(Numeric)
+          return self if other.is_a?(Period)
+
+          minus(other)
+        end
+
+        # @param [TemporalAmount, Numeric] other
+        #   If other is a Numeric, it's interpreted as seconds.
+        # @return [LocalTime]
+        def +(other)
+          return plus(other.seconds) if other.is_a?(Numeric)
+          return self if other.is_a?(Period)
+
+          plus(other)
+        end
+
+        #
+        # Returns the next second
+        #
+        # Will loop back to the beginning of the day if necessary.
+        #
+        # @return [LocalTime]
+        #
+        def succ
+          plus_seconds(1)
+        end
+
+        # @return [self]
+        def to_local_time
+          self
+        end
+
+        # @param [ZonedDateTime, nil] context
+        #   A {ZonedDateTime} used to fill in missing fields
+        #   during conversion. {ZonedDateTime.now} is assumed if not given.
+        # @return [ZonedDateTime]
+        def to_zoned_date_time(context = nil)
+          context ||= ZonedDateTime.now
+          context.with(self)
+        end
+      end
+    end
+  end
+end
+
+LocalTime = OpenHAB::CoreExt::Java::LocalTime unless Object.const_defined?(:LocalTime)
+java.time.LocalTime.include(OpenHAB::CoreExt::Java::Time)

data/lib/openhab/core_ext/java/map.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+# @!visibility private
+module Java::JavaUtil::Map # rubocop:disable Style/ClassAndModuleChildren
+  def compact
+    reject { |_k, v| v.nil? }
+  end
+
+  def compact!
+    reject! { |_k, v| v.nil? }
+    self
+  end
+
+  def deconstruct_keys
+    self
+  end
+
+  def except(*keys)
+    reject { |k, _v| keys.include?(k) }
+  end
+
+  def slice(*keys)
+    select { |k, _v| keys.include?(k) }
+  end
+
+  def transform_keys(hash2 = nil)
+    raise NotImplementedError unless hash2 || block_given?
+
+    map do |k, v| # rubocop:disable Style/MapToHash
+      if hash2&.key?(k)
+        [hash2[k], v]
+      elsif block_given?
+        [(yield k), v]
+      else
+        [k, v]
+      end
+    end.to_h
+  end
+
+  def transform_keys!(hash2 = nil)
+    raise NotImplementedError unless hash2 || block_given?
+
+    keys.each do |k|
+      if hash2&.key?(k)
+        self[hash2[k]] = delete(k)
+      elsif block_given?
+        new_k = yield k
+        self[new_k] = delete(k) unless new_k == k
+      end
+    end
+    self
+  end
+
+  def transform_values
+    map do |k, v| # rubocop:disable Style/MapToHash, Style/HashTransformValues
+      [k, (yield v)]
+    end.to_h
+  end
+
+  def transform_values!
+    replace_all do |_k, v|
+      yield v
+    end
+    self
+  end
+end

data/lib/openhab/core_ext/java/month.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require_relative "time"
+
+module OpenHAB
+  module CoreExt
+    module Java
+      Month = java.time.Month
+
+      # Extensions to {java.time.Month}
+      class Month
+        include Between
+        # @!parse include Time
+
+        # @return [Month]
+        def +(other)
+          plus(other)
+        end
+
+        # @return [Month]
+        def -(other)
+          minus(other)
+        end
+
+        #
+        # Returns the next month
+        #
+        # Will loop back to January if necessary.
+        #
+        # @return [Month]
+        #
+        def succ
+          plus(1)
+        end
+
+        # @return [LocalDate]
+        def to_local_date(context = nil)
+          context ||= java.time.Year.now
+          year = java.time.Year.from(context)
+          year.at_month_day(to_month_day)
+        end
+
+        # @return [Date]
+        def to_date(context = nil)
+          to_local_date(context).to_date
+        end
+
+        # @return [self]
+        def to_month
+          self
+        end
+
+        # @return [MonthDay]
+        def to_month_day
+          MonthDay.of(self, 1)
+        end
+
+        # @param [ZonedDateTime, nil] context
+        #   A {ZonedDateTime} used to fill in missing fields
+        #   during conversion. {ZonedDateTime.now} is assumed if not given.
+        # @return [ZonedDateTime]
+        def to_zoned_date_time(context = nil)
+          to_local_date(context).to_zoned_date_time(context)
+        end
+      end
+    end
+  end
+end
+
+Month = OpenHAB::CoreExt::Java::Month unless Object.const_defined?(:Month)
+java.time.Month.include(OpenHAB::CoreExt::Java::Time)

data/lib/openhab/core_ext/java/month_day.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+require_relative "time"
+
+module OpenHAB
+  module CoreExt
+    module Java
+      java_import java.time.MonthDay
+
+      # Extensions to {java.time.MonthDay}
+      class MonthDay
+        include Between
+        include Ephemeris
+
+        class << self
+          #
+          # Parses strings in the form "M-d"
+          #
+          # @param [String] string
+          # @return [MonthDay]
+          #
+          def parse(string)
+            logger.trace("#{self.class}.parse #{string} (#{string.class})")
+            java_send(:parse, [java.lang.CharSequence, java.time.format.DateTimeFormatter],
+                      string.to_s,
+                      java.time.format.DateTimeFormatter.ofPattern("[--]M-d"))
+          end
+        end
+
+        # @return [String]
+        def to_s
+          # Remove -- from MonthDay string representation
+          to_string.delete_prefix("--")
+        end
+        alias_method :inspect, :to_s
+
+        # wait until we redefine #to_s
+        include Time
+
+        # @return [MonthDay]
+        def +(other)
+          case other
+          when java.time.temporal.TemporalAmount, Numeric
+            (LocalDate.of(1900, month, day_of_month) + other).to_month_day
+          else
+            (to_local_date(other.to_local_date) + other).to_month_day
+          end
+        end
+
+        # @return [MonthDay, Period]
+        def -(other)
+          d = case other
+              when java.time.temporal.TemporalAmount, Numeric
+                LocalDate.of(1900, month, day_of_month) - other
+              else
+                to_local_date(other.to_local_date) - other
+              end
+          return d if d.is_a?(java.time.Period)
+
+          d.to_month_day
+        end
+
+        #
+        # Returns the next day
+        #
+        # Will go to the next month, or loop back to January if necessary.
+        #
+        # @return [MonthDay]
+        #
+        def succ
+          if day_of_month == month.max_length
+            return MonthDay.of(1, 1) if month_value == 12
+
+            return MonthDay.of(month_value + 1, 1)
+          end
+
+          MonthDay.of(month_value, day_of_month + 1)
+        end
+
+        # @param [TemporalAmount, nil] context
+        #   A {TemporalAmount} used to fill in missing
+        #   fields during conversion. {LocalDate.now} is assumed if not given.
+        # @return [LocalDate]
+        def to_local_date(context = nil)
+          context ||= java.time.Year.now
+          year = java.time.Year.from(context)
+          year.at_month_day(self)
+        end
+
+        # @return [Month]
+        alias_method :to_month, :month
+
+        # @param [Date, nil] context
+        #   A {Date} used to fill in missing fields
+        #   during conversion. `Date.today` is assumed if not given.
+        # @return [Date]
+        def to_date(context = nil)
+          context ||= Date.today
+          Date.new(context.year, month_value, day_of_month)
+        end
+
+        # @return [self]
+        def to_month_day
+          self
+        end
+
+        # @param [ZonedDateTime, nil] context
+        #   A {ZonedDateTime} used to fill in missing fields
+        #   during conversion. {ZonedDateTime.now} is assumed if not given.
+        # @return [ZonedDateTime]
+        def to_zoned_date_time(context = nil)
+          to_local_date(context).to_zoned_date_time(context)
+        end
+      end
+    end
+  end
+end
+
+MonthDay = OpenHAB::CoreExt::Java::MonthDay unless Object.const_defined?(:MonthDay)

data/lib/openhab/core_ext/java/period.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+module OpenHAB
+  module CoreExt
+    module Java
+      java_import java.time.Period
+
+      # Extensions to {java.time.Period}
+      class Period
+        # @!parse include TemporalAmount
+
+        #
+        # Convert to number of seconds
+        #
+        # @return [Integer]
+        #
+        def to_i
+          [java.time.temporal.ChronoUnit::YEARS,
+           java.time.temporal.ChronoUnit::MONTHS,
+           java.time.temporal.ChronoUnit::DAYS].sum do |unit|
+            get(unit) * unit.duration.to_i
+          end
+        end
+
+        #
+        # Convert to number of seconds
+        #
+        # @return [Float]
+        #
+        def to_f
+          to_i.to_f
+        end
+
+        remove_method :==
+
+        # @return [Integer, nil]
+        def <=>(other)
+          return to_i <=> other if other.is_a?(Numeric)
+
+          super
+        end
+
+        #
+        # Convert `self` and `other` to {Duration}, if `other` is a Numeric
+        #
+        # @param [Numeric] other
+        # @return [Array, nil]
+        #
+        def coerce(other)
+          return [other.seconds, to_i.seconds] if other.is_a?(Numeric)
+        end
+
+        {
+          plus: :+,
+          minus: :-
+        }.each do |java_op, ruby_op|
+          # def +(other)
+          #   if other.is_a?(Period)
+          #     plus(other)
+          #   elsif other.is_a?(Numeric)
+          #     self + other.seconds
+          #   elsif other.respond_to?(:coerce) && (rhs, lhs = other.coerce(self))
+          #     lhs + rhs
+          #   else
+          #     raise TypeError, "#{other.class} can't be coerced into Period"
+          #   end
+          # end
+          class_eval <<~RUBY, __FILE__, __LINE__ + 1 # rubocop:disable Style/DocumentDynamicEvalDefinition
+            def #{ruby_op}(other)
+              if other.is_a?(Period)
+                #{java_op}(other)
+              elsif other.is_a?(Numeric)
+                self #{ruby_op} other.seconds
+              elsif other.respond_to?(:coerce) && (rhs, lhs = other.coerce(self))
+                lhs #{ruby_op} rhs
+              else
+                raise TypeError, "\#{other.class} can't be coerced into Period"
+              end
+            end
+          RUBY
+        end
+
+        # @!visibility private
+        def *(other)
+          if other.is_a?(Integer)
+            multipliedBy(other)
+          elsif other.respond_to?(:coerce) && (rhs, lhs = other.coerce(self))
+            lhs * rhs
+          else
+            raise TypeError, "#{other.class} can't be coerced into Period"
+          end
+        end
+
+        # @!visibility private
+        def /(other)
+          to_f.seconds / other
+        end
+      end
+    end
+  end
+end
+
+Period = OpenHAB::CoreExt::Java::Period unless Object.const_defined?(:Period)

data/lib/openhab/core_ext/java/temporal_amount.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module OpenHAB
+  module CoreExt
+    module Java
+      java_import java.time.temporal.TemporalAmount
+
+      # Extensions to {java.time.temporal.TemporalAmount}
+      module TemporalAmount
+        # Subtract `self` to {ZonedDateTime.now}
+        # @return [ZonedDateTime]
+        def ago
+          ZonedDateTime.now - self
+        end
+
+        # Add `self` to {ZonedDateTime.now}
+        # @return [ZonedDateTime]
+        def from_now
+          ZonedDateTime.now + self
+        end
+
+        # @return [TemporalAmount]
+        def -@
+          negated
+        end
+
+        # @return [String]
+        def inspect
+          to_s
+        end
+      end
+    end
+  end
+end

data/lib/openhab/core_ext/java/time.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module OpenHAB
+  module CoreExt
+    module Java
+      # Common extensions to Java Date/Time classes
+      module Time
+        # @!parse include Comparable
+
+        # @!visibility private
+        module ClassMethods
+          # The method used to convert another object to this class
+          def coercion_method
+            @coercion_method ||= :"to_#{java_class.simple_name.gsub(/[A-Z]/, "_\\0").downcase[1..]}"
+          end
+
+          # Translate java.time.format.DateTimeParseException to ArgumentError
+          def parse(*)
+            super
+          rescue java.time.format.DateTimeParseException => e
+            raise ArgumentError, e.message
+          end
+        end
+
+        # @!visibility private
+        def self.included(klass)
+          klass.singleton_class.prepend(ClassMethods)
+          klass.remove_method(:==)
+          klass.alias_method(:inspect, :to_s)
+        end
+
+        #
+        # Compare against another time object
+        #
+        # @param [Object] other The other time object to compare against.
+        #
+        # @return [Integer] -1, 0, +1 depending on whether `other` is
+        #   less than, equal to, or greater than self
+        #
+        def <=>(other)
+          if other.is_a?(self.class)
+            compare_to(other)
+          elsif other.respond_to?(:coerce)
+            return nil unless (lhs, rhs = other.coerce(self))
+
+            lhs <=> rhs
+          end
+        end
+
+        # Convert `other` to this class, if possible
+        # @return [Array, nil]
+        def coerce(other)
+          coercion_method = self.class.coercion_method
+          return unless other.respond_to?(coercion_method)
+          return [other.send(coercion_method), self] if other.method(coercion_method).arity.zero?
+
+          [other.send(coercion_method, self), self]
+        end
+      end
+    end
+  end
+end

data/lib/openhab/core_ext/java/unit.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+# @!visibility private
+module Java::JavaxMeasure::Unit # rubocop:disable Style/ClassAndModuleChildren
+  def inspect
+    to_s
+  end
+end
+
+# @!visibility private
+module Java::JavaxMeasure::Dimension # rubocop:disable Style/ClassAndModuleChildren
+  def inspect
+    to_s
+  end
+end