openhab-jrubyscripting 5.0.0.rc1

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

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+require_relative "time"
+
+module OpenHAB
+  module CoreExt
+    module Java
+      java_import 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 Time
+
+        # @!visibility private
+        class << self
+          #
+          # Parses strings in the form "h[:mm[:ss]] [am/pm]"
+          #
+          # @param [String] string
+          # @return [LocalTime]
+          #
+          def parse(string)
+            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)

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

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require_relative "time"
+
+module OpenHAB
+  module CoreExt
+    module Java
+      java_import java.time.Month
+
+      # Extensions to Month
+      class Month
+        include Time
+
+        #
+        # 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
+        end
+      end
+    end
+  end
+end
+
+Month = OpenHAB::CoreExt::Java::Month unless Object.const_defined?(:Month)

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

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+require_relative "time"
+
+module OpenHAB
+  module CoreExt
+    module Java
+      java_import java.time.MonthDay
+
+      # Extensions to MonthDay
+      class MonthDay
+        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)
+          (LocalDate.of(1900, month, day_of_month) + other).to_month_day
+        end
+
+        # @return [MonthDay, Period]
+        def -(other)
+          d = (LocalDate.of(1900, month, day_of_month) - other)
+          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
+
+        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 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 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,58 @@
+# 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)
+          [other.send(self.class.coercion_method), self] if other.respond_to?(self.class.coercion_method)
+        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

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

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+require_relative "time"
+
+module OpenHAB
+  module CoreExt
+    module Java
+      ZonedDateTime = java.time.ZonedDateTime
+
+      # Extensions to ZonedDateTime
+      class ZonedDateTime
+        include Time
+
+        class << self # rubocop:disable Lint/EmptyClass
+          # @!attribute [r] now
+          #   @return [ZonedDateTime]
+        end
+
+        alias_method :to_local_time, :toLocalTime
+        alias_method :to_month, :month
+
+        # @param [TemporalAmount, #to_zoned_date_time, Numeric] other
+        #   If other is a Numeric, it's interpreted as seconds.
+        # @return [Duration] If other responds to #to_zoned_date_time
+        # @return [ZonedDateTime] If other is a TemporalAmount
+        def -(other)
+          if other.respond_to?(:to_zoned_date_time)
+            nanos = other.to_zoned_date_time.until(self, java.time.temporal.ChronoUnit::NANOS)
+            (nanos.to_f / 1_000_000_000).seconds
+          elsif other.is_a?(Numeric)
+            minus(other.seconds)
+          else
+            minus(other)
+          end
+        end
+
+        # @param [TemporalAmount, Numeric] other
+        #   If other is a Numeric, it's interpreted as seconds.
+        # @return [ZonedDateTime]
+        def +(other)
+          return plus(other.seconds) if other.is_a?(Numeric)
+
+          plus(other)
+        end
+
+        #
+        # The number of seconds since the Unix epoch.
+        #
+        # @return [Integer]
+        def to_i
+          to_instant.epoch_second
+        end
+
+        #
+        # The number of seconds since the Unix epoch.
+        #
+        # @return [Float]
+        def to_f
+          to_instant.to_epoch_milli / 1000.0
+        end
+
+        # @return [Date]
+        def to_date
+          Date.new(year, month_value, day_of_month)
+        end
+
+        # @return [LocalDate]
+        def to_local_date(_context = nil)
+          toLocalDate
+        end
+
+        # @return [MonthDay]
+        def to_month_day
+          MonthDay.of(month, day_of_month)
+        end
+
+        # This comes from JRuby
+
+        # @!method to_time
+        #   @return [Time]
+
+        # @param [ZonedDateTime, nil] context
+        #   A {ZonedDateTime} used to fill in missing fields
+        #   during conversion. Not used in this class.
+        # @return [self]
+        def to_zoned_date_time(context = nil) # rubocop:disable Lint/UnusedMethodArgument
+          self
+        end
+
+        # @return [Integer, nil]
+        def <=>(other)
+          # compare instants, otherwise it will differ by timezone, which we don't want
+          # (use eql? if you care about that)
+          if other.respond_to?(:to_zoned_date_time)
+            return to_instant.compare_to(other.to_zoned_date_time(self).to_instant)
+          end
+          return nil unless (lhs, rhs = other.coerce(self))
+
+          lhs <=> rhs
+        end
+
+        #
+        # Converts `other` to {ZonedDateTime}, if possible
+        #
+        # @param [#to_zoned_date_time] other
+        # @return [Array, nil]
+        #
+        def coerce(other)
+          [other.to_zoned_date_time(self), self] if other.respond_to?(:to_zoned_date_time)
+        end
+      end
+    end
+  end
+end
+
+# @!parse ZonedDateTime = OpenHAB::CoreExt::Java::ZonedDateTime

data/lib/openhab/core_ext/ruby/array.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+# Extensions to Array
+class Array
+  #
+  # Ensure an object is an array, by wrapping
+  # it in an array if it's not already an array.
+  # @return [Array]
+  #
+  # @see https://github.com/rails/rails/blob/main/activesupport/lib/active_support/core_ext/array/wrap.rb
+  #
+  def self.wrap(object)
+    if object.nil?
+      []
+    elsif object.respond_to?(:to_ary)
+      object.to_ary
+    else
+      [object]
+    end
+  end
+end

data/lib/openhab/core_ext/ruby/class.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+# Extensions to Class
+class Class
+  #
+  # Returns the name of the class, without any containing module or package.
+  #
+  # @return [String, nil]
+  #
+  def simple_name
+    return unless name
+
+    @simple_name ||= java_class&.simple_name || name.split("::").last
+  end
+end