openhab-scripting 4.46.2 → 5.0.0

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

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+module OpenHAB
+  module CoreExt
+    module Java
+      Duration = java.time.Duration
+
+      # Extensions to {java.time.Duration Java Duration}
+      class Duration
+        include Between
+        # @!parse include TemporalAmount
+
+        #
+        # Convert to integer number of seconds
+        #
+        # @return [Integer]
+        #
+        alias_method :to_i, :seconds
+
+        #
+        # @!method zero?
+        #   @return [true,false] Returns true if the duration is zero length.
+        #
+
+        #
+        # @!method negative?
+        #   @return [true,false] Returns true if the duration is less than zero.
+        #
+
+        unless instance_methods.include?(:positive?)
+          #
+          # @return [true, false] Returns true if the duration is greater than zero.
+          #
+          def positive?
+            self > 0 # rubocop:disable Style/NumericPredicate
+          end
+        end
+
+        #
+        # Convert to number of seconds
+        #
+        # @return [Float]
+        #
+        def to_f
+          to_i + (nano / 1_000_000_000.0)
+        end
+
+        remove_method :==
+
+        # @return [Integer, nil]
+        def <=>(other)
+          return to_f <=> other if other.is_a?(Numeric)
+
+          super
+        rescue TypeError
+          nil
+        end
+
+        #
+        # Converts `other` to {Duration}, if possible.
+        #
+        # @param [Numeric, Period] other
+        # @return [Array, nil]
+        #
+        def coerce(other)
+          return [other.seconds, self] if other.is_a?(Numeric)
+          return [other.to_i.seconds, self] if other.is_a?(Period)
+        end
+
+        {
+          plus: :+,
+          minus: :-
+        }.each do |java_op, ruby_op|
+          # def +(other)
+          #   if other.is_a?(Duration)
+          #     plus(other)
+          #   elsif other.is_a?(Integer)
+          #     plus_seconds(other)
+          #   elsif other.is_a?(Numeric)
+          #     plus(other.seconds)
+          #   elsif other.respond_to?(:coerce) && (rhs, lhs = other.coerce(self))
+          #     lhs + rhs
+          #   else
+          #     raise TypeError, "#{other.class} can't be coerced into Duration"
+          #   end
+          # end
+          class_eval <<~RUBY, __FILE__, __LINE__ + 1 # rubocop:disable Style/DocumentDynamicEvalDefinition
+            def #{ruby_op}(other)
+              if other.is_a?(Duration)
+                #{java_op}(other)
+              elsif other.is_a?(Integer)
+                #{java_op}_seconds(other)
+              elsif other.is_a?(Numeric)
+                #{java_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 Duration"
+              end
+            end
+          RUBY
+        end
+
+        {
+          multipliedBy: :*,
+          dividedBy: :/
+        }.each do |java_op, ruby_op|
+          # def *(other)
+          #   if other.is_a?(Integer)
+          #     multipliedBy(other)
+          #   elsif other.is_a?(Numeric)
+          #     Duration.of_seconds(to_f * other)
+          #   elsif other.is_a?(Duration)
+          #     Duration.of_seconds(to_f * other.to_f)
+          #   elsif other.respond_to?(:coerce) && (rhs, lhs = other.coerce(self))
+          #     lhs * rhs
+          #   else
+          #     raise TypeError, "#{other.class} can't be coerced into Duration"
+          #   end
+          # end
+          class_eval <<~RUBY, __FILE__, __LINE__ + 1 # rubocop:disable Style/DocumentDynamicEvalDefinition
+            def #{ruby_op}(other)
+              if other.is_a?(Integer)
+                #{java_op}(other)
+              elsif other.is_a?(Numeric)
+                Duration.of_seconds(to_f #{ruby_op} other)
+              elsif other.is_a?(Duration)
+                Duration.of_seconds(to_f #{ruby_op} other.to_f)
+              elsif other.respond_to?(:coerce) && (rhs, lhs = other.coerce(self))
+                lhs #{ruby_op} rhs
+              else
+                raise TypeError, "\#{other.class} can't be coerced into Duration"
+              end
+            end
+          RUBY
+        end
+      end
+    end
+  end
+end
+
+# @!parse Duration = OpenHAB::CoreExt::Java::Duration

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

@@ -0,0 +1,436 @@
+# frozen_string_literal: true
+
+# @!visibility private
+module Java::JavaUtil::List # rubocop:disable Style/ClassAndModuleChildren
+  extend Forwardable
+
+  def_delegators :to_a,
+                 :&,
+                 :*,
+                 :|,
+                 :bsearch_index,
+                 :difference,
+                 :flatten,
+                 :intersection,
+                 :pack,
+                 :product,
+                 :repeated_combination,
+                 :repeated_permutation,
+                 :reverse,
+                 :rotate,
+                 :sample,
+                 :shelljoin,
+                 :shuffle,
+                 :transpose,
+                 :union
+
+  def assoc(obj)
+    find { |v| (v.is_a?(Array) || v.is_a?(self.class)) && v[0] == obj }
+  end
+
+  def at(index)
+    self[index]
+  end
+
+  def bsearch(&block)
+    raise NotImplementedError unless block
+
+    r = bsearch_index(&block)
+    self[r] if r
+  end
+
+  def combination(n, &block) # rubocop:disable Naming/MethodParameterName
+    r = to_a.combination(n, &block)
+    block ? self : r
+  end
+
+  def compact
+    reject(&:nil?)
+  end
+
+  def compact!
+    reject!(&:nil?)
+  end
+
+  def concat(*other_arrays)
+    other_arrays.each { |array| add_all(array) }
+    self
+  end
+
+  def deconstruct
+    self
+  end
+
+  def delete(obj)
+    last = nil
+    found = false
+    loop do
+      i = index(obj)
+      break if i.nil?
+
+      found = true
+      last = remove(i)
+    end
+
+    return yield(obj) if !found && block_given?
+
+    last
+  end
+
+  def delete_at(index)
+    index = length + index if index.negative?
+    return if index.negative? || index >= length
+
+    remove(index)
+  end
+
+  def delete_if
+    raise NotImplementedError unless block_given?
+
+    it = list_iterator
+    while it.has_next? # rubocop:disable Style/WhileUntilModifier
+      it.remove if yield(it.next)
+    end
+    self
+  end
+
+  def dig(index, *identifiers)
+    return self[index] if identifiers.empty?
+
+    self[index]&.dig(*identifiers)
+  end
+
+  def each_index(&block)
+    r = (0...length)
+    return r.each unless block
+
+    r.each(&block)
+    self
+  end
+
+  def fetch(index, *default_value)
+    if default_value.length > 1
+      raise ArgumentError,
+            "wrong number of arguments calling `fetch` (given #{default_value.length - 1}, expected 1..2)"
+    end
+
+    original_index = index
+    index = length + index if index.negative?
+    return self[index] if index >= 0 && index < length
+
+    return default_value.first unless default_value.empty?
+    return yield(original_index) if block_given?
+
+    raise IndexError, "index #{index} out of list"
+  end
+
+  def fill(*args)
+    if block_given?
+      unless (0..2).cover?(args.length)
+        raise ArgumentError,
+              "wrong number of arguments calling `fill` (given #{args.length}, expected 1..3)"
+      end
+    else
+      unless (1..3).cover?(args.length)
+        raise ArgumentError,
+              "wrong number of arguments calling `fill` (given #{args.length}, expected 1..2)"
+      end
+    end
+
+    obj = args.shift unless block_given?
+
+    if args.length == 1 && args.first.is_a?(Range)
+      range = args.first
+
+      range = Range.new(length + range.begin, range.end, range.exclude_end?) if range.begin.negative?
+      range = Range.new(range.begin, length + range.end, range.exclude_end?) if range.end&.negative?
+      return self if range.begin.negative? || (range.end && range.end < range.begin)
+    else
+      first, count = *args
+      return self if count&.negative?
+
+      first ||= 0
+
+      first = length + first if first.negative?
+      range = count ? first...(first + count) : first..
+    end
+
+    add(nil) while length < range.begin && count
+
+    start = range.begin
+    start = 0 if start.negative?
+    start = length if start > length
+    it = list_iterator(start)
+
+    while range.cover?(it.next_index)
+      break if range.end.nil? && !it.has_next?
+
+      obj = yield(it.next_index) if block_given?
+      if it.has_next?
+        it.next
+        it.set(obj)
+      else
+        it.add(obj)
+      end
+    end
+
+    self
+  end
+
+  def flatten!(*args)
+    if args.length > 1
+      raise ArgumentError,
+            "wrong number of arguments calling `flatten` (given #{args.length}, expect 0..1)"
+    end
+
+    it = list_iterator
+
+    args = [args.first - 1] unless args.empty?
+    done = args.first == 0 # rubocop:disable Style/NumericPredicate
+
+    changed = false
+    while it.has_next?
+      element = it.next
+      next unless element.respond_to?(:to_ary)
+
+      changed = true
+      it.remove
+      arr = element.to_ary
+      arr = arr.flatten(*args) unless done
+      arr.each do |e|
+        it.add(e)
+      end
+    end
+    changed ? self : nil
+  end
+
+  def insert(index, *objects)
+    return self if objects.empty?
+
+    raise IndexError, "index #{index} too small for list, minimum: #{-length}" if index < -length
+
+    index = length + index + 1 if index.negative?
+
+    add(nil) while length < index
+    add_all(index, objects)
+    self
+  end
+
+  def intersect?(other_ary)
+    !(self & other_ary).empty?
+  end
+
+  def keep_if?
+    raise NotImplementedError unless block_given?
+
+    it = list_iterator
+    while it.has_next? # rubocop:disable Style/WhileUntilModifier
+      it.remove unless yield(it.next)
+    end
+    self
+  end
+
+  def map!(&block)
+    raise NotImplementedError unless block
+
+    replace_all(&block)
+    self
+  end
+
+  def permutation(n, &block) # rubocop:disable Naming/MethodParameterName
+    r = to_a.permutation(n, &block)
+    block ? self : r
+  end
+
+  def pop(*args)
+    if args.length > 1
+      raise ArgumentError,
+            "wrong number of arguments calling `pop` (given #{args.length}, expected 0..1)"
+    end
+
+    if args.empty?
+      return if empty?
+
+      return remove(length - 1)
+    end
+
+    count = args.first
+    start = [length - count, 0].max
+    result = self[start..-1].to_a # rubocop:disable Style/SlicingWithRange
+    it = list_iterator(start)
+    while it.has_next?
+      it.next
+      it.remove
+    end
+    result
+  end
+
+  def push(*objects)
+    add_all(objects)
+    self
+  end
+  alias_method :append, :push
+
+  def rassoc(obj)
+    find { |v| (v.is_a?(Array) || v.is_a?(self.class)) && v[1] == obj }
+  end
+
+  def reject!
+    raise NotImplementedError unless block_given?
+
+    it = list_iterator
+    changed = false
+    while it.has_next
+      if yield(it.next)
+        changed = true
+        it.remove
+      end
+    end
+    self if changed
+  end
+
+  def repeated_combination(n, &block) # rubocop:disable Naming/MethodParameterName
+    r = to_a.repeated_combination(n, &block)
+    block ? self : r
+  end
+
+  def repeated_permutation(n, &block) # rubocop:disable Naming/MethodParameterName
+    r = to_a.repeated_permutation(n, &block)
+    block ? self : r
+  end
+
+  def replace(other_array)
+    clear
+    add_all(other_array)
+    self
+  end
+
+  def reverse!
+    replace(reverse)
+    self
+  end
+
+  def rotate!(count = 1)
+    count = count % length
+    push(*shift(count))
+    self
+  end
+
+  def select!
+    raise NotImplementedError unless block_given?
+
+    it = list_iterator
+    changed = false
+    while it.has_next?
+      unless yield(it.next)
+        changed = true
+        it.remove
+      end
+    end
+    self if changed
+  end
+
+  def shift(*args)
+    if args.length > 1
+      raise ArgumentError,
+            "wrong number of arguments calling `shift` (given #{args.length}, expected 0..1)"
+    end
+
+    if args.empty?
+      return if empty?
+
+      return remove(0)
+    end
+
+    count = args.first
+    result = self[0...count].to_a
+    it = list_iterator
+    count.times do
+      break unless it.has_next?
+
+      it.next
+      it.remove
+    end
+    result
+  end
+
+  def shuffle!(*args)
+    replace(shuffle(*args))
+  end
+
+  def slice(*args)
+    self[*args]
+  end
+
+  def slice!(*args)
+    unless (1..2).cover?(args.length)
+      raise ArgumentError,
+            "wrong number of arguments calling `slice!` (given #{args.length}, expected 1..2)"
+    end
+
+    return delete_at(args.first) if args.length == 1 && !args.first.is_a?(Range)
+
+    start = args.first
+    start = start.begin if start.is_a?(Range)
+    start = length + start if start.negative?
+    return nil if start.negative? || start >= length
+
+    result = slice(*args).to_a
+
+    it = list_iterator(start)
+    result.length.times do
+      it.next
+      it.remove
+    end
+    result
+  end
+
+  def sort_by!
+    raise NotImplementedError unless block_given?
+
+    sort { |a, b| (yield a) <=> (yield b) }
+    self
+  end
+
+  def uniq!
+    seen = Set.new
+
+    it = list_iterator
+    changed = false
+    while it.has_next?
+      n = it.next
+      n = yield(n) if block_given?
+      if seen.include?(n)
+        changed = true
+        it.remove
+      end
+      seen << n
+    end
+    self if changed
+  end
+
+  def unshift(*objects)
+    add_all(0, objects)
+    self
+  end
+  alias_method :prepend, :unshift
+
+  def values_at(*indexes)
+    result = []
+    indexes.each do |index|
+      if index.is_a?(Range)
+        partial_result = self[index]
+        result.concat(partial_result)
+        result.fill(nil, result.length, index.count - partial_result.length)
+      else
+        index = length + index if index.negative?
+        result << if index.negative? || index >= length
+                    nil
+                  else
+                    self[index]
+                  end
+      end
+    end
+    result
+  end
+end

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

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+require_relative "time"
+
+module OpenHAB
+  module CoreExt
+    module Java
+      java_import java.time.LocalDate
+
+      # Extensions to {java.time.LocalDate}
+      class LocalDate
+        include Time
+        include Between
+        include Ephemeris
+
+        # @!scope class
+
+        # @!attribute [r] now
+        #   @return [LocalDate]
+
+        # @!method parse(text, formatter=nil)
+        #   Converts the given text into a LocalDate.
+        #   @param [String] text The text to parse
+        #   @param [java.time.format.DateTimeFormatter] formatter The formatter to use
+        #   @return [LocalDate]
+
+        # @!scope instance
+
+        # @param [TemporalAmount, LocalDate, Numeric] other
+        #   If other is a Numeric, it's interpreted as days.
+        # @return [LocalDate] If other is a TemporalAmount or Numeric
+        # @return [Period] If other is a LocalDate
+        def -(other)
+          case other
+          when Date
+            self - other.to_local_date
+          when MonthDay
+            self - other.at_year(year)
+          when LocalDate
+            Period.between(other, self)
+          when Duration
+            minus_days(other.to_days)
+          when Numeric
+            minus_days(other.ceil)
+          else
+            minus(other)
+          end
+        end
+
+        # @param [TemporalAmount, Numeric] other
+        #   If other is a Numeric, it's interpreted as days.
+        # @return [LocalDate]
+        def +(other)
+          case other
+          when Duration
+            plus_days(other.to_days)
+          when Numeric
+            plus_days(other.to_i)
+          else
+            plus(other)
+          end
+        end
+
+        #
+        # Returns the next day
+        #
+        # @return [LocalDate]
+        #
+        def succ
+          plus_days(1)
+        end
+
+        # @return [Date]
+        def to_date
+          Date.new(year, month_value, day_of_month)
+        end
+
+        # @return [Month]
+        alias_method :to_month, :month
+
+        # @return [MonthDay]
+        def to_month_day
+          MonthDay.of(month, day_of_month)
+        end
+
+        # @return [self]
+        def to_local_date(_context = nil)
+          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)
+          zone = context&.zone || java.time.ZoneId.system_default
+          at_start_of_day(zone)
+        end
+      end
+    end
+  end
+end
+
+LocalDate = OpenHAB::CoreExt::Java::LocalDate unless Object.const_defined?(:LocalDate)